Goal Trigger on forms submit

 

Goal Trigger on forms submit:

• Create a Sitecore form.
• Select Submit button.
  
  
  
  
  
• Click on the "+" icon and select the "Trigger Goal".
  
  
  
  
  
• It will open the modal popup and select the Goal which has you created and click on the "Ok" button.
  
  

  

  
  
• Now you can see the selected goal, Click on Apply button and publish the forms.
  
  

  

  
  
• Once you submit the forms then it will update the Analytics dashboard.
  
  
  

  

  
  

  

Associate a goal with page items

Associate a goal with page items

 

Associate a goal with page items:

You can associate a goal with a content item in the Experience Editor or in the Content Editor. You use the Media Library or Content Editor to associate a goal with a media item.

To associate a goal with an item:

• From the Sitecore Launchpad, open the Experience Editor or the Content Editor, then navigate to the relevant content item.
• In the Attributes group, click Goals.
• In the Experience Editor, this is located on the Optimization tab.
  
  
  
  
  
• In the Content Editor, this is located on the Analyze tab.
  
  
  
  
• In the Goals dialog, select the goal that you want to associate with this item and click OK.

Goal Trigger on forms submit

Sitecore Goals

Goal

• Goals are activities that visitors can perform on your website. You create goals to track and measure how visitors engage with the website and campaigns – both online and offline.
• All goals are events, but not all events are goals.
• Goals can be “tagged” on specific pages on your website.

In this demo, we have to learn how to create goals and associate with Page Items or Goal Trigger on forms submit in Sitecore.

Create and deploy a goal

• In Marketing Control Panel, in the content tree, click Goals.
  
  
  
• On the Home tab, in the Insert group, click Goal to create a new goal.
  
  
  
  
  
• In the dialog box that appears, enter a name for the goal.
  
  
  
  
  
  
• On the Content tab, you can enter more detailed information about the goal, such as engagement value points or a description.
  
  
  
  
  
• Click on the Save button.
  
• To deploy the goal, on the Review tab, in the Workflow group, click Deploy.
  
  
  
  
  Now you can associate the goal with content items and campaigns.
  
• To publish the goal, on the Publish tab, in the Publish group, click Publish.

Associate a goal with page items

Goal Trigger on forms submit

Email Experience Manager (Automated) - Quick Setup

Email Experience Manager

Use the email experience manager (EXM) to create highly customizable email campaigns and make them both personal and relevant to your customers.

Email experience manager does not support CMS-only mode.

Email Experience Manager (EXM), there are two types of email campaigns and each has a set of templates that contain default content and layout.

1. Regular email campaign - This type does not have any predefined content or recipients, so you create this type of email campaign from scratch. 
2. Automated email campaign – This type is used to send a single email to one contact at a time.

Out of the Box, Sitecore enables EXM by default and sets up the Mail Distribution provider as the CustomSMTP provider. However, the provider settings must be set up in order to send an email. This post will dive into how to set those settings. I will explain how to set up the EXM module in Sitecore 9.x for dev machine usage.

1. Custom Email SMTP configuration: To send the email from Sitecore, you just need to configure the SMTP server, I am using MailTrap.io SMTP settings.

• Set up MailTrap.io account: Mailtrap is a fake SMTP server to test, view, and share emails sent from the development and staging environments. It allows you to test email notifications without sending them to the real users of the application. All emails sent to Mailtrap are held in your Mailtrap inbox where you can test, view, and share with your team. To create an account, visit https://mailtrap.io and signup.
  
  
• Once set up, you can see SMTP settings.
  
  
  

2. The EXM configuration settings: In this section, we will do all required configuration changes.

• Now go to web.config file of the root folder of the application. Search the key called “eds:define” in the web.config and make sure the value should be “CustomSMTP”.
  
  
  
  
  
• Go to \App_Config\Sitecore\EmailExperience\Sitecore.EDS.Providers.CustomSMTP.config
  
  
  
  
  
  
• Update the SMTP setting in the smtpSetting node as below.
  
  

3. Testing Your MTA Connection: On any Sitecore EXM Manager Root item, there is a Test Connection button in the Content Editor.

Clicking on this button will test your connection to your Mail Transit Authority (MTA). A successful connection to the MTA service will display the following.

4. Email Experience Manager Module: Now as all configurations are done, let’s play with the EXM module in Sitecore, and send your first email from the Sitecore application. Open the EXM module on the Sitecore dashboard.

• Create the email campaign > Click create > Regular Email Campaign/Automated email campaign. We have created an Automated email campaign for this demo.
  
  

• Once you click on "Automated" then the modal popup opens and you can select the default template or Import your HTML template or you select the exit page item then click on the "Create" button.

 

• In the general information tab, you can configure some basic information of the email campaign for example name, description, etc, in the sender section you can configure “from name” and email, which will show in the email box.
  
  
  
  
  
  
• In the Message tab, we can make the message template what looks like in the mailbox.
  
  
• In the Delivery tab click on Activate to activate the campaign.
  
  
  

  
  
  
  
  
  

Creating a custom pipeline in Sitecore

What is a Pipeline?

• A pipeline is basically a method whose flow is defined using XML.
• A pipeline consists of a sequence of processors. A processor is a .NET class that implements a method. When a pipeline is invoked, the processors are run in order.

What are Custom Processors?

While there is neither a class to extend nor an interface to implement, a convention must be followed in order for Sitecore to be in order for a class to be used as a processor:

• If the processor has a method specified, the method must accept a PipelineArgs object and return void.
• If the processor does not have a method specified, the processor must have a method named Process which accepts a PipelineArgs object and returns void.

The following is an example of a custom processor.

public class SetVal1

{

    public void Process(MyPipelineArgs args)

    {

        Sitecore.Diagnostics.Assert.ArgumentNotNull(args, "args");

        //do something

    }

}

Creating a Custom Pipeline

Creating custom pipelines is an essential part of integrating an external system with Sitecore.

• PipelineArgs
• Defining a Pipeline
• Invoking a Pipeline

PipelineArgs

When creating a custom pipeline a custom PipelineArgs class is not required. The standard PipelineArgs class can be used.

However, a custom PipelineArgs class makes it easier to pass objects between processors and to provide output to the process called the pipeline. At runtime, the PipelineArgs object acts as the pipeline’s context.

In order to create a custom PipelineArgs class, you must inherit from Sitecore.Pipeline.PipelineArgs.

public class MyPipelineArgs : Sitecore.Pipelines.PipelineArgs

    {

        public string Result { get; set; }

    }

Defining a Pipeline

A pipeline itself is nothing more than a block of XML in the configuration > Sitecore > pipelines section of Web.config or a Sitecore patch file.

The following is an example of a custom pipeline definition.

<?xml version="1.0" encoding="utf-8" ?>

<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">

  <sitecore>

    <pipelines>

      <myPipeline>

        <processor type="SitecoreLearning.Helpers.CustomProcessor.SomeProcessor, SitecoreLearning" />

      </myPipeline>

    </pipelines>

  </sitecore>

</configuration>

Invoking a Pipeline

Create the processor class(es):

public class SomeProcessor

    {

        public void Process(MyPipelineArgs args)

        {

            args.Result = GetResult();    // Write a bussines logic here what are you want to implment.

        }

        private string GetResult()

        {

            return "Hello custom pipeline world";

        }

    }

To call the pipeline we use the CorePipeline.Run method as follows:

 var pipelineArgs = new MyPipelineArgs();

 Sitecore.Pipelines.CorePipeline.Run("myPipeline", pipelineArgs);  // Invoking a Pipeline

 Log.Info(pipelineArgs.Result, this);

This is how simple it is to create a custom pipeline.

Custom Event in Sitecore

Custom Event in Sitecore

• Events in Sitecore are similar to events in other systems: something triggers an event and there are handlers that are configured to handle the event.

• Event handlers are similar to pipelines in how they are configured. An event handler is a .NET class that implements a method. When an event is triggered, the event handlers are run in order.

• Event handlers are defined in Sitecore patch files. 

Adding an Event Handler

While there is neither a class to extend nor an interface to implement, a convention must be followed in order for Sitecore to be in order for a class to be used as an event handler.

The class must have a method that accepts two parameters and return void:

object - represents the object that holds a collection of the various event listeners

EventArgs - holds the parameters being passed to the event handler

The following is an example of a custom processor.

public class MyEventHandlers

{

    public void OnItemSaved(object sender, EventArgs args)

    {

        //do something

    }

}

Defining an Event

An event itself is nothing more than a block of XML in the /configuration/Sitecore/events section of a Sitecore patch file.

The following is an example of a custom event definition.

<testing:myevent>
  <processor type="Testing.Events.SetVal1, Testing" />
  <processor type="Testing.Events.SetVal2, Testing" />
</testing:myevent>

Raising an Event

The following is an example of raising an event.

public class EventRaiser

{

  public void RaiseEvent()

  {

    var args = new Testing.Events.MyEventArgs();

    Sitecore.Events.Event.RaiseEvent("testing:myevent", args);

  }

}

Example of custom Event:

using System;

using Sitecore.Pipelines;

namespace SitecoreLearning.Helpers.CustomEvent

{

    /*A custom EventArgs class makes it easier to pass objects between event handlers and to provide output to the process that triggered the event. 

     At runtime, the EventArgs object acts as the event’s context.

     create a custom EventArgs class you must inherit from System.EventArgs. */

    public class EventRemote: System.EventArgs

    {

        public string ItemId { get; set; }

    }

    public class EventHandlers

    {

        public virtual void InitializeFromPipeline(PipelineArgs args)

        {

            Sitecore.Diagnostics.Log.Info("EventHandlers.InitializeFromPipeline() called", this);

            var action = new Action<EventRemote>(RaiseRemoteEvent);

            Sitecore.Eventing.EventManager.Subscribe<EventRemote>(action);

        }

        private void RaiseRemoteEvent(EventRemote myEvent)

        {

            Sitecore.Diagnostics.Log.Info("EventHandlers.RaiseRemoteEvent() called", this);

            Sitecore.Events.Event.RaiseEvent("event:happened:remote", new object[] { myEvent.ItemId });

        }

    }

    public class EventManager

    {

        /*

         Adding an Entry to the Event Queue, Next, you need to add an entry to the event queue. 

         Often it makes sense to trigger the local event and to add the remote event to the event queue at the same time. 

         The following is an example of this.

        */

        public static void RaiseEventRemote()

        {

            Sitecore.Diagnostics.Log.Info("EventManager.RaiseEventRemote() called", typeof(EventManager));

            var parameters = new object[] { new Guid().ToString() };

            Sitecore.Events.Event.RaiseEvent("event:happened", parameters);

        }

        public void OnEvent(object sender, EventArgs args)

        {

            Sitecore.Diagnostics.Log.Info("EventManager.OnEvent() called", this);

        }

        public void OnEventRemote(object sender, EventArgs args)

        {

            Sitecore.Diagnostics.Log.Info("EventManager.OnEventRemote() called", this);

        }

    }

}

Note: call the static method in your business logic then the event handler will be called automatically.

Defined in Sitecore patch files:

<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">

  <sitecore>

    <pipelines>

      <initialize>

        <processor type="SitecoreLearning.Helpers.CustomEvent.EventHandlers, SitecoreLearning" method="InitializeFromPipeline" />

      </initialize>

    </pipelines>

    <events>

      <!--Start custom Events -->

      <event name="event:happened">

        <handler type="SitecoreLearning.Helpers.CustomEvent.EventManager, SitecoreLearning" method="OnEvent" />

      </event>

      <event name="event:happened:remote">

        <handler type="SitecoreLearning.Helpers.CustomEvent.EventManager, SitecoreLearning" method="OnEventRemote" />

      </event>

      <!--End custom Events -->

    </events>

  </sitecore>

</configuration>

Part - 4 Integrate SonarQube with Visual Studio using SonarLint

Part - 1 SonarQube Installation on Windows
Part - 2 Analyze code Using SonarQube
Part - 3 SonarQube Connect with SQL Server

What is SoanrLint?

SonarLint is an IDE extension that helps you detect and fix quality issues as you write code. Like a spell checker, SonarLint squiggles flaws so that they can be fixed before committing code.

SonarLint an extension you can add to an IDE such as Visual Studio that can provide developers real-time feedback on the quality of the code. It can detect issues in seconds, which can improve productivity. SonarSource describes SonarLint as a capability that can work like a spell checker for text since it detects issues in your code as you go.

In this post, we will be discussing how you can enable SonarLint in Visual Studio to get real-time feedback on the quality of your code. This project assumes that you already have a running instance of SonarQube on a server.

Installation

In Visual Studio, SonarLint is an extension that can be installed by going to the following:

Tools -> Extensions and Updates -> Online

Then in the search box, search for “SonarLint”. Once you see SonarLint, press “Download”.

You must now sign out of Visual Studio to let the changes save properly. VSIX Installer will prompt you to allow for it to modify Visual Studio. After this is completed, you can now use SonarLint for your project.

After the restart of Visual Studio, you should have a new entry in the “Analyze” menu called “Manage SonarQube Connections…”:

Using SonarLint in your project

Open the project you want to connect with SonarQube, click on the following:

Analyze -> Manage SonarQube Connections

A new entry called “SonarQube” will be shown in the Team Explorer window.

(If you don’t have an open project the connect link in the left bottom corner will be grey and inactive. Is this the case, open a project and it will turn into a link.)
Then you will need to press “Connect” to connect to your SonarQube Server. Add in the SonarQube server, username, and password information.

SonarLint will now connect to your SonarQube server and show you a list of your projects:

Now you can tell SonarLint to which SonarQube project your current solution belongs. With that link created, SonarLint can now fetch the project-specific rules from SonarQube. This is the reason we do all that linking and connecting. From now on your changes in the rule set in SonarQube will be synchronised to Visual Studio.

This synchronisation ensures that your Visual Studio only checks what needs to be checked and nothing else.

Analyse your code

You can now analyze your code. You can do this with the following:

Right click solution -> Analysis -> Run Code Analysis

If there are any errors or issue with your code, you will see it in the “Error List” box built into Visual Studio. Moreover, you will be able to see the UI line items directly in Visual Studio. Normally, you would need to log into the SonarQube web application directly to get this information.

Another benefit of SonarLint in Visual Studio is that you will see a helper notify you with errors or warnings as you write code. This allows you to fix code right away in real-time. This can drastically improve efficiency for developers and it will help reduce the time needed for code checks.

Improving code quality

You can write the code as you did before. But now you get a new helper that can warn you while you work.

This doesn’t look like a big improvement, but give it a try. The integration is neat and simple and helps you when you want to listen. Should you want to ignore it you simply close the window – your build server can remind you later on that you should improve that piece of code you just wrote.