Tuesday, September 1, 2015PrintSubscribe
“Calendar” View For You

Applications created with Code On Time use a well defined entity model that prescribes presentation of data as grid and form views and determines transition of views via actions. Data may come from any source. For example, a developer can defined an SQL query or stored procedure to read data from the database. An entity can also be programmed to read/write data from a web service, file system, or any other source. Application framework interprets the entity and displays data in various view styles. For example, a typical grid view can be rendered as responsive grid, list, collection of data cards, map, and charts. Request an interactive Webex presentation to learn more.

“Calendar” is a brand new view style that will become available with update on September 2, 2015 . A presence of a “date” field will tell application framework that there is possibility of rendering data as a calendar. New view style offers Day, Week, Month, Year, and Agenda modes. Any field in the view can serve as a “color” field. The framework will assign a color to each data value.  End users can drag and drop events to change values of date fields. Standard form view of an entity is display when an event is selected enabling seamless editing of data.

“Day” view in the screen shot shows 4 data records rendered as events.

'Day' mode in calendar view of an app created with Code On Time.

Mini calendar on the side bar uses bold font to indicate dates of the month with events. Mini calendar alternates presentation of data between day and week mode when a particular date is clicked. Color legend shows associated data values, which represents the name of the employee assigned to the “order” event. An “event” is a record from Orders table of the Northwind sample.

“Week” view offers seven days of events. Future updates are expected to support 3 and 4 day weeks. Both “Day” and “Week” view are infinitely horizontally scrollable.

'Week' mode in calendar view of an app created with Code On Time.

“Month” view offers infinitely scrollable events organized in months.

'Month' mode in calendar view of an app created with Code On Time.

Click on any item in the color map on the sidebar and the application will “dim” events associated with other employees in “Day”, “Week”, “Month”, and “Agenda” views.

'Dimming' of events is possible by tapping on the color legend in 'Day', 'Week', 'Month', and 'Agenda' modes of calendar view style in apps created with Code On Time.

“Year” view offers analytical presentation of an entire year and also enables quick data-driven navigation to a month or a specific day.

'Year' view in Calendar view style of an app created with Code On Time.

“Agenda” view provides a convenient condensed summary list of events with a dynamic timeline.

'Agenda' view in Calendar view style of an app created with Code On Time.

All modes of the calendar view style are responsive. Smartphone users will see presentation scaled to fit the form factor of their device. For example, these two screen shots demonstrate “Day” and “Agenda” view on a typical smart phone.

'Day' view in Calendar view style of an app created with Code On Time displayed on a screen with small form factor.   'Agenda' view in Calendar view style of an app created with Code On Time displayed on a screen with small form factor.

These amazing capabilities require no programming or coding. Developers can opt to disable the calendar when not desired. Otherwise application will simply offer the end user yet another way to see their data.

Calendar view now joins a first class collection of presentations styles that were made available in the previous releases and greatly enhanced with this new iteration. View selector and sidebar provide access to every view style available for a particular dataset.

Selecting a view style for data presentation in an app created with Code On Time.

For example, charts view displays automatically constructed charts without developer writing any code.  Any number of custom charts can be defined when needed at design time.

'Charts' view style in an app created with Code On Time.

“Cards” view presents data items as multi-line cards with the same size. Application framework breaks each three fields in paragraphs offering another way to see data. Cards presented in 3, 2, or 1 column based on the screen size. The screenshot shows two columns of automatically configured cards.

'Cards' view style in an app created with Code On Time.

“List” view is the most universal presentation style that will work with fields of any length and any screen size. Field values float from left to right and continue on the next line.

'List' view style in an app created with Code On Time.

“Grid” view style enhances responsive presentation by introducing automatic data balancing. The new release reduces the number of visible columns by applying 2, 5, 8, 10, and 12 column breakpoints based on screen size when data is rendered. This makes it possible to display a grid of rows with “important” fields without being forced to scroll horizontally. For example, this screenshot shows five columns of data rows in Orders table.

Responsive 'Grid' view style in an app created with Code On Time.

Developers can indicate the minimal screen size that a particular column must be displayed on. For example, tag “grid-tn” will force a column to show up even on “tiny” screen. Small screes with show every column marked as “grid-sm”. The release notes of the update will explain expected logical pixels of tiny, extra small, small, medium, large, and extra large screens.

Previous release required explicit tagging of each field. The new approach is to assume that all fields must be displayed if possible. The mere intent of a developer to place a field in a grid implies that it must visible. Developer-defined tags simply enforcing display of fields on particular screen sizes in responsive grid. The next screenshot shows 8 columns displayed when the sidebar is not visible. Automatic data balancing ensures that “shorter” fields reclaim more real estate from “longer” fields with enforced minimal width to ensure quality “balanced” presentation of data in columns with fixed width.

Long press brings up a context menu with data sensitive options in an app created with Code On Time.

All view styles also support “long press” that allows displaying of context menu and selection of records on both desktop and touch-enabled devices. The screenshot above shows context-sensitive filtering and sorting options.

“Map” view style is one more method of presenting data that becomes available when latitude/longitude or Address/City fields are present in the gird view.

'Map' view style in an app created with Code On Time.

Context menus and data cards are now displayed at the bottom of the screen on devices with small form factor to enable easy touch operations. A couple of screenshots below show data card of “Map” view style and view selector on a small screen.

Data card displayed on a screen with small form factor presented by app created with Code On Time.   Context menu displayed on a screen with small form factor presented by app created with Code On Time.

The standard collection of presentation styles will be enhanced with horizontally scrollable “Datasheet” view and “Hierarchy” view styles. The implementation of remaining view style is well under way and is based on horizontal scrolling mechanism that was developed and perfected with “Calendar” view.

Thursday, July 24, 2014PrintSubscribe
Touch UI for Any Data, Anywhere (Stored Procedures, Web Services, etc.)

Code On Time release introduces ability to generate custom data controllers directly from Project Designer. The source of data is up to you – the app generator will handle any data anywhere! Create amazing Touch and Desktop UI for data returned from stored procedures, web services, file system, etc.  The release also introduces a collection of important bug fixes and performance improvements. Continue reading for the full list.

Generating Controllers from Project Explorer

Create a new data controller, right-click the corresponding node in Project Explorer and choose Generate from SQL option to create a data controller based on a free-form SELECT statement , stored procedure, or any other SQL script .

'Generate from SQL' and 'Generate from Fields' options in Code On Time app generator.

“Command Text”  Controller

If the script is an arbitrary SELECT statement, then indicate that the script defines a command text. This option will configure a custom command for the data controller and ensure the maximum efficiency at runtime. You can also specify an optional “base” table name if you want the controller to support Update, Insert, and Delete.

Configuring a data controller based on arbitrary SELECT statement in Code On Time app generator.

Verify the script and click OK. Copy and paste the new controller on any page.

An app with Touch UI created with Code On Time.

“Business Rule” Controller

If you want to configure a data controller based on a stored procedure, then you will need to indicate that the script defines a business rule.

Configuring a data controller based on a stored procedure in Code On Time.

The controller will be enhanced with a collection of business rules. There will be no command.

Rule enableResultSet will instruct application framework to use the custom result set.

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

Rule getData will produce the result set.

EXEC    [dbo].[Employee Sales by Country]
        @Beginning_Date = N'1/1/1980',
        @Ending_Date = N'1/1/2014'

Note that Update, Insert, and Delete are prevented by default.

set @BusinessRules_PreventDefault = 1
-- implement insert here

Implement your own business logic in the corresponding SQL or “Code” business rules. The output of the stored procedure will be stored in an instance of DataTable class. Developers can specify optional cache duration to improve performance of controllers based on “slow” stored procedures.

Business rules of a data controller based on a stored procedure displayed in Project Explorer of Code On Time app generator for desktop and mobile devices.

Drop the controller on a page to see it in action.

A data controller based on a stored procedure displayed in Touch UI application created with Code On Time.

“Thin Air” Controller

If you data is not coming from the database, then use another approach. Define a collection of fields for the new data controller. Right-click the data controller and choose Generate from Fields option. This will create a collection of “Code” business rules that produce an empty DataTable class instance with the columns matching the data controller fields.

A custom data controller produces data from 'thin' air in an app created with Code On Time.

Implement the code to populate the DataTable instance in the file that contains GetData business rule.

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

Namespace MyCompany.Rules

    Partial Public Class CustomDataSource3BusinessRules
        Inherits MyCompany.Data.BusinessRules

        ''' <summary>
        ''' This method will execute in any view before an action
        ''' with a command name that matches "Select".
        ''' </summary>
        <Rule("GetData")> _
        Public Sub GetDataImplementation()
            ResultSet = CreateCustomDataSource3DataTable()
        End Sub

        Private Function CreateCustomDataSource3DataTable() As DataTable
            Dim dt As DataTable = New DataTable()
            dt.Columns.Add("Title", GetType([String]))
            dt.Columns.Add("Published", GetType(DateTime))
            dt.Columns.Add("Reviewed", GetType(DateTime))
            ' Populate rows of table "dt" with data from any 
' source (web service, file system, database, etc.) '
Dim r As DataRow = dt.NewRow() r("Title") = "Building modern applications with Code On Time" r("Published") = New DateTime(2014, 12, 15) dt.Rows.Add(r) Return dt End Function End Class End Namespace

Note that Update, Insert, and Delete commands are prevented by default. You can implement your own routines when needed. Also make sure that you have specified the primary key fields to allow selection of data .

Here is the data controller in a live application.

A data from 'thin' air displayed in an app with Touch UI created with Code On Time app generator.

This feature is available in all product editions. Detailed tutorials with step-by-step instructions will be published later this week.

Bug Fixes and Enhancements

The release includes an important fix for Unlimited edition users. Generated applications were failing previously if the browser was not supplying Accept Encoding header in HTTP requests, which resulted in a non-function page displayed to the end users in both Desktop and Touch UI. The web server was reporting HTTP error 400 (Bad request).

Application framework will also not execute custom business rules twice. The bug was introduced in the previous release.

Business rules are not executed for the selected and unchecked row when multiple selection is enabled in Desktop UI.

This is the list of other enhancements and bug fixes included in the release:

  • Non-IE desktop browsers will not report “Invalid date” message in Touch UI.
  • Touch UI updates all visible summary views in Touch UI when a page is resized.
  • Filter information and "Clear" option are displayed correctly in master and detail context menus in Touch UI.
  • Summary views in Touch UI do not wrap "See All" option on the next line.
  • Touch UI displays "Showing N items." message in the view description.
  • Item styles RadioButtonList, ListBox and CheckBoxList are now supported in Touch UI. The latter enables many-to-many fields.
  • Method $ will not strip "focus" from the active tab on touch-enabled devices.
  • Touch UI now uses action header text, command name, and command argument to eliminate duplicate actions from the context menu. Previous implementation has relied on command name and argument only, which have resulted in “lost” context menu options.
  • Fixed the bug in Quick Find that was causing incorrect search results when fields "shorter" than the search sample are present in a grid/list view.
  • Navigating to a "hashed" url of a protected page will not cause a duplicate history event in webkit browsers.
  • Page title is displayed inline when sidebar is visible to allow more space for toolbar buttons.
  • Taphold on field value in a grid column will display a popup with a complete text of the field value if the value is partially hidden.
  • Touch UI allows static text selection with a mouse in desktop browsers.
  • Fixed page height decrease caused by a refresh of a summary view in Touch UI.
  • Removed "keyup" and "keydown" events causing appscrolling  event in wrappers in Touch UI applications.
  • Taphold can be done with Ctrl+Click when using a mouse in Touch UI applications. The other option is to press the mouse button down and holding it at least 750 milliseconds before release.
  • Fixed ResetSkipCount method to ensure that a correct page is loaded from Result Set under all conditions.
  • User and Role manager have been improved for a consistent behavior in Desktop and Touch UI apps.
  • Sync of selected key value is performed by application framework if the number of submitted key values matches the number of primary key fields.
  • Focus on an input field in Touch UI will also select the field value.
  • Blob key field is converted to a string when a check for "null" BLOB field is performed in Touch UI.
  • Removed icons-png folder from the ~/touch/images folder of generated apps. The complete set of SVG icons available in Touch UI are now listed in ~/touch/icons.html file includes in every project.
  • Fixed Export exception when server rules are null.
  • Ensured EnableMinifiedCss is generated for all users.

The next release will be out in early August of 2014. We expect to include further enhancements to the Touch UI and a new server-side Reporting API that will produce binary reports on the server. The feature will also be extended to Email Business Rules to enable reports as attachments.

Thursday, December 26, 2013PrintSubscribe
Mobile Database Apps for iPhone/iPad/Android, Visual Studio 2013
Code On Time release introduces an updated Universal Mobile/Desktop Client in the apps created with Premium and Unlimited editions. The new mobile client offers editing capabilities and Responsive Web Design. The same exact app will take a full advantage of the client mobile device and offer the most efficient method of presenting data. Continue reading for full release notes after the screen shots.
See the live mobile demo at
These are the screen shots of iPhone 5s with the product list and a single product in an edit form.
Mobile client rendering of a product list in the app created with Code On Time app generator.  Mobile client rendering of an edit form 'editForm1' in the app created with Code On Time app generator.
Modern tablets feature high resolution screens. iPad Air with portrait orientation in shown in the screen shot below with the display of the same product list. List items are wider and a fixed context sidebar is automatically visible on the right-hand side of the screen.
Mobile client rendering of a product list in iPad Air with visible context sidebar in the app created with Code On Time app generator.
This screen shot shows the product list in iPad Air with landscape orientation. The context sidebar has been undocked to offer three columns of list items.
Mobile client rendering of a product list in iPad Air with landscape orientation in the app created with Code OnTime app generator.
Don’t forget that apps created with Unlimited edition also support Desktop client devices. See the desktop version of the demo at
Mobile client rendering of a product list in iPad Air with landscape orientation in the app created with Code OnTime app generator.
Application framework automatically detects the type of client device and hooks either mobile or desktop client library to rendered application pages ensuring the most friendly presentation.
The following features and bug fixes are included in this release:
  • Updated mobile client library with full editing capabilities and Responsive Web Design.
  • Production release of jQuery Mobile 1.4 is the foundation of the mobile client library.
  • Visual Studio 2013 is now supported.
  • Windows Azure SDK 2.2. is now supported.
  • Client library supports "lookup-details-hidden" tag to hide "arrow" that allows view object details from lookup fields.
  • Thumbnails of images are now rendered on transparent background. Previous releases where rendering images with white background and thin gray frame.
  • Web.Config.Release and Web.Config.Debug transformations are now supported in Web App Factory and Azure Factory apps.
  • Application page builder will prevent creation of duplicate pages and configure the first foreign key field as Filter Source field if multiple FK fields are referencing the same controller.
  • Import processor passes the name of the temporary file to ImportProcessorFactory to allow overriding and correction of the submitted import file.
  • Import processor will automatically bind records imported into child data views to the primary key of a selected master on any level of hierarchy.
  • Thank you Ed Blum for contributing "nl-NL" enhanced localization.
  • Method DataViewExtender.AssignFilter will accept an array of values for Include and Exclude filters.
  • Removed extraneous ")" from the project build file that was preventing Web App Factory from generating the Login page.
  • Spansh style of "a.m./p.m" designator is using "space" in the middle on Window 8.1. The client library will correctly parse time.
  • Legacy apps without /project/features/framework/@scriptOnly set to "true" in DataAquiarum.Project.xml file will not try to render Mobile Client.
  • Desktop client correctly positions Calendar in all browsers.
  • Desktop client correctly processes selected lookup values in FireFox.
  • Desktop client does not apply the URL command parameters to object Details when a user clicks on an arrow.
  • Removed "x" button in IE10 and above in desktop apps.
Next release is planned for January of 2014. There will be numerous enhancements to the mobile client to further narrow the gap between Desktop and Mobile features. Here is a partial list of things we are working on:
  • Blob upload/download.
  • Confirmation data controllers
  • Multi-field copy and context fields in lookups.
  • Dedicated presentation for Auto Complete, Check Box, and Check Box List lookup styles.
  • Filtering capabilities.
  • Mobile version of Advanced Search Bar.
  • Display of aggregates in context sidebar.
  • “Tabular” display of data lists.
  • Multiple-selection of list items.
  • Conditional visibility of categories and fields.
  • Conditional read-only fields.
  • Calculated fields.
We are also preparing to showcase We have done tremendous amount of work to bring built-in dynamic page creation, workflows, blogging and support forum capabilities to the apps created with Unlimited edition of Code On Time. Stay tuned.