Business Rules/Logic

The Subtotal field is now present in the application. The field does not reflect changes when new order items are entered. We will add a business rule to the Orders controller and add a code expression for Subtotal. This code expression will use the rule to calculate the subtotal.

In the Project Explorer, switch to Controllers tab. Double-click on the Orders controller. In the Handler field, type:

OrdersBusinessRules

Press OK to save the controller, exit the Designer, and Generate the project. The business rule placeholder file will be created.

When generation is complete, click on the project name in the web application generator and press Develop. Microsoft Visual Studio or Visual Web Developer will open. In the Solution Explorer on the right side of the screen, double-click on App_Code /Rules / OrdersBusinessRules.cs(vb).

Paste in the following code:

C#:

using MyCompany.Data;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
namespace MyCompany.Rules
{
    public partial class OrdersBusinessRules : MyCompany.Data.BusinessRules
    {
        public decimal CalculateOrderDetailsTotal(int? orderID)
        {
            using (SqlText calc = new SqlText(@"select sum(unitprice * 
                    quantity * (1 - discount)) from 
                    [Order Details] where OrderID= @OrderID"))
            {
                calc.AddParameter("@OrderID", orderID);
                object total = calc.ExecuteScalar();
                if (DBNull.Value.Equals(total))
                    return 0;
                else
                    return Convert.ToDecimal(total);
            }
        }
    }
}

VB:

Imports MyCompany.Data
Imports System
Imports System.Collections.Generic
Imports System.Data
Imports System.Linq
Namespace MyCompany.Rules

    Partial Public Class OrdersBusinessRules
        Inherits MyCompany.Data.BusinessRules
        Public Function CalculateOrderDetailsTotal(
                            ByRef orderID As Nullable(Of Integer)) As Decimal
            Using calc As SqlText = New SqlText(
                    "select sum(unitprice * quantity * (1 - discount)) " +
                    "from [Order Details] where OrderID=@OrderID")
                calc.AddParameter("@OrderID", orderID)
                Dim total As Object = calc.ExecuteScalar()
                If DBNull.Value.Equals(total) Then
                    Return 0
                Else
                    Return Convert.ToDecimal(total)
                End If
            End Using
        End Function
    End Class
End Namespace

This function uses SqlText utility class to create an instance of a query connected to the project’s database.
This simple query selects a sum of UnitPrice multiplied by Quantity multiplied by one minus the
Discount.

Note that SqlText utility class is generated as a part of the code base of your application. It uses the
default database connection string and ADO.NET to execute the query.

Save the file, and switch back to the application generator. Select the project name, and press Design. In the Project Explorer, switch to Controllers. Double-click on Orders / Fields / Subtotal. Make the following changes:

CalculateOrderDetailsTotal(orderID)

Press OK to save the field. The Subtotal field on the Order Form will now update to reflect any changes made to the order details.

ASP.NET developers depend on the intrinsic  objects exposed as properties Request, Response, Session, and a few others in the code classes inherited from System.Web.UI.Page and System.Web.UI.UserControl.  Everything there is to know about the current web request and mechanism to produce an adequate response is encapsulated in these objects.

Microsoft SharePoint application developers similarly depend on the class Microsoft.SharePoint.SPContext also known as SharePoint Context.

ASP.NET developers may tap in the application foundational infrastructure  via System.Web.HttpContext class when programming web request processing logic outside of the boundaries of pages and user controls. For example, Code On Time applications are extended with business rules, which are not based on the pages. The application framework creates business rules classes in response to AJAX requests to process custom aspects of the application business logic.

For example, the following business rule written in Visual Basic will keep assigning an ever increasing generic label “New Product N” by replacing “N” with the counter whenever a new product is created in the Northwind sample.

Imports MyCompany.Data
Imports System

Namespace MyCompany.Rules

    Partial Public Class ProductsBusinessRules
        Inherits MyCompany.Rules.SharedBusinessRules

        <RowBuilder("Products", RowKind.New)> _
        Public Sub PrepareNewProductRow()
            Dim count As Nullable(Of Integer) = HttpContext.Current.Session("ProductCount")
            If Not count.HasValue Then
                count = 1
            Else
                count = count + 1
            End If
            HttpContext.Current.Session("ProductCount") = count
            UpdateFieldValue("ProductName", "New Product " + count.ToString())
        End Sub

    End Class
End Namespace

The method interacts with the user session object via Current static property of HttpContext class.

HttpContext.Current.Session("ProductCount")

SharePoint developers use exactly the same technique. The entire universe of Microsoft SharePoint server infrastructure is available via Current static property of SPContext class.

Business rule developers can take advantage of the shortcut property named Current to make interaction with ASP.NET runtime a little shorter.

Context.Session("ProductCount")

There is no shortcut that would allow access the SharePoint Context in the same fashion. As a matter of fact the application class library in a SharePoint Factory project does not even reference Microsoft SharePoint assemblies.

We have deliberately constructed the SharePoint Factory application generation project to be a solution composed of three Visual Studio projects. Only the project named WebParts is directly dependent on the SharePoint .

The class library of the project incorporates the entire application source code and resources including JavaScript, images, and CSS style sheets. Project named WebApp is used by the application generator to preview the application at design time.

Injection of SharePoint dependencies in either the class library or WebApp will make it impossible to preview the result of project customization. SharePoint is a 64-bit environment. Code On Time relies on IIS Express, the 32-bit application, for preview of generated web sites. These two are simply not compatible.

If you are building line-of-business web applications then having a direct SharePoint dependency can become obsolete with SharePoint Factory. In a matter of minutes your can generate an app straight from your database, customize it without having any idea about the actual intricacies of development with the rather complex SharePoint environment. Publish your application and the WebParts project will make the miracle of turning your app in a native citizen of the SharePoint Server a reality.

If you do need to take full advantage of vast capabilities of Microsoft SharePoint then with a little bit of effort you will outperform your peers and deliver amazing native SharePoint apps – SharePoint Factory will not let you down.

Right-click the WebParts project of your solution and select Set as StartUp Project option in the context menu.

Expand the class library node of the solution, right-click References. Select option Add Reference. Note that if you are developing a Visual Basic application then right-click the class library project name instead.

Find the SharePoint namespace on the .NET tab of Add Reference dialog and click OK.

Choose File | Save All option in the Visual Studio menu.

Start the web application generator, click on the name of your project and choose Settings. Select Business Logic Layer and proceed to enable shared business rules.

Click Finish button. You will end up on the Summary page. Click Cancel  to return to the start page of the generator.

Select the project name on the start page of the application generator one more time and choose Settings. Activate Web Server Configuration settings

Uncheck “Run application upon completion of code generation” option and click Finish.

This time generate your project.

Select the project name on the start page and choose Develop to launch the Visual Studio development environment. You will be prompted to authorize the elevated permissions required for SharePoint development.

Double-click the shared business rules class of the class library project to open it in the text editor.

Enter the following code in the class definition. The class implements a method that allows verifying if a the current SharePoint application user belong to a certain SharePoint user group.

C#

using System;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using MyCompany.SPDemo.Data;
using Microsoft.SharePoint;

namespace MyCompany.SPDemo.Rules
{
    public partial class SharedBusinessRules : MyCompany.SPDemo.Data.BusinessRules
    {

        public bool BelongsToGroup(string name)
        {
            foreach (SPGroup group in SPContext.Current.Web.CurrentUser.Groups)
                if (group.Name.Equals(name))
                    return true;
            return false;
        }
    }
}

Visual Basic:

Imports MyCompany.SPDemoVB.Data
Imports System
Imports System.Collections.Generic
Imports System.Data
Imports System.Linq
Imports Microsoft.SharePoint

Namespace Rules

    Partial Public Class SharedBusinessRules
        Inherits MyCompany.SPDemoVB.Data.BusinessRules

        Public Function BelongsToGroup(ByVal name As String) As Boolean
            For Each group As SPGroup In SPContext.Current.Web.CurrentUser.Groups
                If (group.Name.Equals(name)) Then
                    Return True
                End If
            Next
            Return False
        End Function

    End Class
End Namespace

Microsoft SharePoint takes advantage of Windows Active Directory and also contributes a proprietary method of organizing users. This method empowers SharePoint administrators to create application-specific user groups that do not necessarily match the corporate domain organization.

Our method will scan the groups assigned to the current user and will return true if the match is found.

The base class BusinessRules implements the method UserIsInRole. The method allows verifying if the current user is a member of an Active Directory user group. Our new addition effortlessly enhances the framework with the ability to analyze membership in the SharePoint user groups.

Let’s take advantage of this method.

Click on the project name on the start page of the code generator and select Design. Activate the Controllers tab in Project Explorer and double-click any data controller. Our sample has been built from the Adventure Works 2008 R2 database. We will customize the HumanResources_Shift data controller. Enter the name of the custom business rule class that will handle the life-cycle of your data controller.

We have entered “ShiftBusinessRules” in the Handler property. Make sure to click OK button to save the changes.

Exit the designer and click Generate.

Return to Visual Studio – you will be prompted to reload the project.

The new file will show in the project solution under the Rules folder of the application class library.

Double-click the file name and enter the following code.

C#:

using System;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using MyCompany.SPDemo.Data;
using System.Xml;
using System.Xml.XPath;

namespace MyCompany.SPDemo.Rules
{
    public partial class ShiftBusinessRules : MyCompany.SPDemo.Rules.SharedBusinessRules
    {
        public override bool SupportsVirtualization(string controllerName)
        {
            return true;
        }

        public override void VirtualizeController(string controllerName,
            XPathNavigator navigator, XmlNamespaceManager resolver)
        {
            if (BelongsToGroup("Team Site Owners"))
            {
                XPathNavigator grid1 = navigator.SelectSingleNode(
                    "//c:view[@id='grid1']/c:headerText", resolver);
                if (grid1 != null)
                    grid1.SetValue(
                        "Welcome, <b>Site Owner</b>. These are the shifts that you can see.");
            }
        }

        [AccessControl("", "ShiftID", "[Name]='Night'")]
        public void ShowTheNightShiftOnlyToTeamSiteOwners()
        {
            if (BelongsToGroup("Team Site Owners"))
                RestrictAccess();
        }
    }
}

Visual Basic:

Imports MyCompany.SPDemoVB.Data
Imports System
Imports System.Collections.Generic
Imports System.Data
Imports System.Linq
Imports System.Xml
Imports System.Xml.XPath

Namespace Rules
    
    Partial Public Class ShiftBusinessRules
        Inherits MyCompany.SPDemoVB.Rules.SharedBusinessRules

        Public Overrides Function SupportsVirtualization(controllerName As String) As Boolean
            Return True
        End Function

        Public Overrides Sub VirtualizeController(controllerName As String,
                navigator As XPathNavigator, resolver As XmlNamespaceManager)
            If (BelongsToGroup("Team Site Owners")) Then
                Dim grid1 As XPathNavigator = navigator.SelectSingleNode(
                    "//c:view[@id='grid1']/c:headerText", resolver)
                If (Not grid1 Is Nothing) Then
                    grid1.SetValue(
                        "Welcome, <b>Site Owner</b>. These are the shifts that you can see.")
                End If
            End If
        End Sub

        <AccessControl("", "ShiftID", "[Name]='Night'")> _
        Public Sub ShowTheNightShiftOnlyToTeamSiteOwners()
            If (BelongsToGroup("Team Site Owners")) Then
                RestrictAccess()
            End If
        End Sub
    End Class
End Namespace

The code will virtualize the Shift controller by changing the header text of the grid view to a custom text if the current user belongs to Team Site Owners group.

It also restricts the list of shifts to the “Night” shift only. The actual database contains “Day” and “Evening” shifts as well but there is nothing the user from the group “Team Site Owners” can do to see the data.

The default instance of Microsoft SharePoint Foundation is configured to execute in Minimal trust mode. Open “C:\inetpub\wwwroot\wss\VirtualDirectories\80\web.config” file in a text editor and make sure to that the trust is set to at least “Medium” or “High” level.

<trust level="WSS_Medium" originUrl="" />

Run the solution. Visual Studio will deploy the solution to your local SharePoint instance. Place the application web part on any site page and activate the logical page named “Human Resources | Shift”.

Save changes in the part editor and exit the page edit mode.

If you are the site owner then this is what you will see.

Only the “Night” shift is visible.  Also a custom message will be displayed at top of the Shift grid view.

The applications users that do not belong to the Team Site Owners group will not be affected by virtualization and access control rule.