Forms, Reports, Apps

Build and deploy rapidly. Use offline, online, on-premises.

  Blog

Blog
Saturday, August 16, 2014PrintSubscribe
Producing Reports in Binary Format

Application end users download the data reports by selecting menu options in the user interface.

Standard reporting options in an app with Touch UI produced with Code On Time application generator.

The report is produced in the requested format on the server and streamed back to the client browser. The report data is automatically filtered and sorted exactly as displayed to the end user.

A report produced in Microsoft Word format by an app with Touch UI created with Code On Time application generator.

Application developers may need to produce a report on the server with arbitrary filters and sort expression in response to the user actions. The report data file may be stored in the database, archived in the file system, or sent as an email attachment. Application framework offers a simple method that allows to do just that.

Consider the following sample business rule.

C#:

using System;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Security;
using MyCompany.Data;
using MyCompany.Handlers;
using System.IO;
using MyCompany.Web;

namespace MyCompany.Rules
{
    public partial class CustomersBusinessRules : MyCompany.Data.BusinessRules
    {

        /// <summary>
        /// This method will execute in any view for an action
        /// with a command name that matches "Custom" and argument that matches "ProduceReport".
        /// </summary>
        [Rule("r100")]
        public void r100Implementation(string customerID, string companyName, string contactName,
            string contactTitle, string address, string city, string region, string postalCode,
            string country, string phone, string fax)
        {
            // This is the placeholder for method implementation.
            ReportArgs args = new ReportArgs();
            // controller
            args.Controller = "Orders";
            // sort expression
            args.SortExpression = "OrderDate desc";
            // data filter
            args.Filter = new FieldFilter[] {
                new FieldFilter  {
                    FieldName = "CustomerID",
                    Operation = RowFilterOperation.Equal,
                    Value = customerID
                }
            };
            // filter details
            args.FilterDetails = "This report has been produced on the server for customer " + companyName;
            // produce report in binary format
            byte[] reportData = Report.Execute(args);
            // save report to the local file system
            File.WriteAllBytes(Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "Test.pdf"),
                reportData);
            // report the MIME type and file extension that go with the binary data
            Result.ShowAlert("MIME: {0}, Extension: {1}", args.MimeType, args.FileNameExtension);
        }
    }
}

Visual Basic:

Imports MyCompany.Data
Imports System
Imports System.Collections.Generic
Imports System.Data
Imports System.Linq
Imports System.Text.RegularExpressions
Imports System.Web
Imports System.Web.Security
Imports MyCompany.Handlers
Imports System.IO
Imports MyCompany.Web

Namespace MyCompany.Rules

    Partial Public Class CustomersBusinessRules
        Inherits MyCompany.Data.BusinessRules

        ''' <summary>
        ''' This method will execute in any view for an action
        ''' with a command name that matches "Custom" and argument that matches "ProduceReport".
        ''' </summary>
        <Rule("r100")> _
        Public Sub r100Implementation(ByVal customerID As String, ByVal companyName As String,
                                      ByVal contactName As String, ByVal contactTitle As String,
                                      ByVal address As String, ByVal city As String,
                                      ByVal region As String, ByVal postalCode As String,
                                      ByVal country As String, ByVal phone As String, ByVal fax As String)
            'This is the placeholder for method implementation.
            Dim args As ReportArgs = New ReportArgs()
            ' controller
            args.Controller = "Orders"
            ' sort expression
            args.SortExpression = "OrderDate desc"
            ' data filter
            args.Filter = New FieldFilter() {
                New FieldFilter With {
                    .FieldName = "CustomerID",
                    .Operation = RowFilterOperation.Equals,
                    .Value = customerID
                    }
                }
            ' filter details
            args.FilterDetails = "This report has been produced on the server for customer " + companyName
            ' produce report in binary format
            Dim reportData As Byte() = Report.Execute(args)
            ' save report to the local file system
            File.WriteAllBytes(Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "Test.pdf"),
                reportData)
            ' report the MIME type and file extension that go with the binary data
            Result.ShowAlert("MIME: {0}, Extension: {1}", args.MimeType, args.FileNameExtension)
        End Sub
    End Class
End Namespace

The code is executed in response to a custom action Produce Report selected in the context menu of application.

Custom action used to invoke a 'Code' business rule in an app with Touch UI creatd with Code On Time application builder.

Static method Report.Execute performs a server-side execution of the standard report action. The custom implementation of the “Code” business rule displays details about the produced binary data array.

Information about MIME type and file extension reporting by a business rule after producing a report in PDF format in an app with Touch UI.

This sample saves the report data to My Documents folder of the server computer. Here is the actual report.

This report has been generated by a custom action with the help of Report.Execute method invoked by custom business rule in an app with Touch UI produced with Code On Time.

Instance of a class ReportArgs exposes several properties that control the report rendering on the server.

Property Description
Controller Specifies the name of the data controller.
View Specifies the ID of the data controller view that will be used to produce data.
SortExpression Defines a sort expression that determines the order of data rows passed to the reporting engine for processing.
Filter Defines an array of filters applied to the report data passed to the reporting engine for processing.
FilterDetails Specifies the optional message displayed below the report header in standard reports.
Format Specifies the format of the output. The default format is Pdf. Other options are Word, Excel, and Image.
Template Name Specifies the name of the custom report template. If left blank, then a standard template is automatically created by application framework.
MimeType Indicates the MIME type of the report data produced by Microsoft Report Viewer. Use this property when sending report as an email attachment.
FileNameExtension Indicates the file name extension that matches the data produced by Microsoft Report Viewer. Use this property to provide a correct extension for the file name.
Friday, August 15, 2014PrintSubscribe
Improving Performance Of Reports in ASP.NET 4.0 and 4.5 Applications

Microsoft Report Viewer is the lightweight reporting engine used by generated apps to produce data reports in PDF, Word, Excel, and TIFF format. A generated app creates an in-memory table of data sorted and filtered according to the end user criteria. The data table is passed to Report Viewer to produce a report. The design template of the report is either created on-the-fly by the application framework or supplied by a developer at design time.

Report Viewer allows including formulas written in Visual Basic in the definitions of property expressions in various elements of a report template. The report formulas from the template are compiled to executable code by Report Viewer. If an ASP.NET web application tries to create a  report with the help of Microsoft Report Viewer, then certain security requirements must be satisfied. The formulas compiled by Report Viewer must run in “sandbox” environment.

ASP.NET security configuration has changed starting with ASP.NET 4.0. Now the sandbox of Report Viewer is required to jump through many hoops in order to produce a report. This results in poor performance of reports  on large datasets requiring significantly more time to complete rendering.

A simple solution exists to overcome this problem in an app created with Code On Time.

1) Select the project name on the start page of the app generator and choose Settings.

2) Proceed to Web Server Configuration and paste the following snippet into Web.Config modification instructions box:

AppendChild: /configuration/system.web

<trust legacyCasModel="true"/>

3) Click Finish and regenerate the project. A new <trust…/> entry will be created in the configuration file of application.

Now the reporting performance will become significantly improved.

Saturday, August 9, 2014PrintSubscribe
Passing Parameter to Stored Procedure using a Custom Search Dialog

Code On Time apps offer the ability to display the results of a stored procedure. Some stored procedures require passing an SQL parameter in order to perform manipulations on the data.

In the Northwind sample database, the [Employee Sales By Country] stored procedure shows total sales amounts grouped by employee, and then by country. It accepts two parameters, @Starting_Date and @Ending_Date to determine the filter.

Let’s create a controller from this stored procedure. By default, the stored procedure will display all records between the years 1970 and 2000. In addition, we will add a custom action that will allow the user to specify the Beginning and Ending dates via a custom confirmation controller.

The picture below shows the confirmation controller form allowing the user to specify parameters for the stored procedure.

The confirmation controller form allows the user to select a beginning and ending date to pass to the stored procedure.

The CREATE script for the stored procedure can be seen below.

CREATE procedure [dbo].[Employee Sales by Country] 
@Beginning_Date DateTime, @Ending_Date DateTime AS
SELECT    Employees.Country, 
        Employees.LastName, 
        Employees.FirstName, 
        Orders.ShippedDate, 
        Orders.OrderID, 
        "Order Subtotals".Subtotal AS SaleAmount
FROM Employees INNER JOIN 
    (Orders INNER JOIN "Order Subtotals" ON Orders.OrderID = "Order Subtotals".OrderID) 
    ON Employees.EmployeeID = Orders.EmployeeID
WHERE Orders.ShippedDate Between @Beginning_Date And @Ending_Date

Creating the Controller to Display the Stored Procedure

Start the Project Designer. In the Project Explorer, switch to the Controllers tab. Click on the New Controller icon on the toolbar.

Creating a new controller.

Enter a name for the controller.

Property Value
Name EmployeeSalesByCountry

Press OK to save. Right-click the new controller and press “Generate From SQL…”.

Generating the controller from SQL.

In the SQL script textbox, paste in the following script. The debug section is removed from the business rule when the application framework executes the script at runtime and declares the parameters.

-- debug
DECLARE @Session_BeginningDate datetime, @Session_EndingDate datetime
-- end debug

if (@Session_BeginningDate is null)
    set @Session_BeginningDate = '1970'

if (@Session_EndingDate is null)
    set @Session_EndingDate = '2000'


EXEC [dbo].[Employee Sales by Country]
    @Session_BeginningDate,
    @Session_EndingDate

Press OK to generate the controller.

Setting the Session Variable

Note that the parameters returned from the search dialog will not be cached. These parameters must be saved into a session variable. In the Project Explorer, double-click on the EmployeeSalesByCountry / Business Rules / Select (Sql / Before) – enableResultSet node.

Selecting the 'enableResultSet' business rule from the EmployeeSalesByCountry controller.

Replace the script with the following:

set @BusinessRules_EnableResultSet = 1
-- Enable caching of the result set. Duration is specified in seconds.
-- set @BusinessRules_ResultSetCacheDuration = 30 

if (@Parameters_BeginningDate is not null)
    set @Session_BeginningDate = @Parameters_BeginningDate

if (@Parameters_EndingDate is not null)
    set @Session_EndingDate = @Parameters_EndingDate

Press OK to save the new script.

Adding Controller To Page

Next, let’s add the controller to a page. Right-click on the controller and press Copy.

Copying the 'EmployeeSalesByCountry' controller.

Switch to the Pages tab in the Project Explorer. On the toolbar, press the New Page icon.

Adding a page to the app.

Give a name to the page and press OK to save.

Property Value
Name Employee Sales By Country

Drop the new page to the right side of Home page node to place it second in the site menu.

Dropping a page to the right of the Home page node.     Employee sales by country page is now second in the site menu.

Right-click on the page and press Paste to instantiate the controller as a data view on the page.

Pasting onto the 'Employee Sales By Country' page.     The EmployeeSalesByCountry controller has been instantiated as a view on the page.

Adding the Custom Action

Switch back to the Controllers tab in the Project Explorer. Right-click on EmployeeSalesByCountry / Actions / ag3 (ActionBar) – New node, and press New Action.

Creating a new action in the 'EmployeeSalesByCountry' controller.

Specify the following values:

Property Value
Command Name Search
Header Text Filter View
Confirmation

_controller=FilterEmployeeSales
_title=Select the Beginning and Ending Dates

Press OK to save the action.

Creating the Confirmation Controller

Let’s add a controller that will allow the user to specify BeginningDate and EndingDate parameters for the stored procedure.

On the Project Explorer toolbar, press the New Controller icon.

Adding a new controller to the project.

Enter a name for the controller.

Property Value
Name

FilterEmployeeSales

Click OK to save the controller. Right-click on FilterEmployeeSales / Fields node, and press New Field.

Adding a new field to the 'FilterEmployeeSales' controller.

Define the field as follows:

Property Value
Name BeginningDate
Type DateTime

Save the field, and create a second field with these values:

Property Value
Name EndingDate
Type DateTime

Save the EndingDate field. The confirmation controller is now complete.

Viewing the Results

On the Project Designer toolbar, press Browse. In the browser window that will open, navigate to the Employee Sales By Country page. Note that all 809 records are displayed.

All 809 records are displayed on the 'Employee Sales By Country' page.

In the sidebar or context menu, press Filter View action. The page will navigate to a form with the Beginning Date and Ending Date fields. Enter values, and press OK.

The confirmation controller form allows the user to select a beginning and ending date to pass to the stored procedure.

Note that the parameters have been passed to the stored procedure and there are only 17 records displayed now.

The BeginningDate and EndingDate parameters have been set by the confirmation controller.