JavaScript

Labels
AJAX(112) App Studio(7) Apple(1) Application Builder(245) Application Factory(207) ASP.NET(95) ASP.NET 3.5(45) ASP.NET Code Generator(72) ASP.NET Membership(28) Azure(18) Barcode(2) Barcodes(3) BLOB(18) Business Rules(1) Business Rules/Logic(140) BYOD(13) Caching(2) Calendar(5) Charts(29) Cloud(14) Cloud On Time(2) Cloud On Time for Windows 7(2) Code Generator(54) Collaboration(11) command line(1) Conflict Detection(1) Content Management System(12) COT Tools for Excel(26) CRUD(1) Custom Actions(1) Data Aquarium Framework(122) Data Sheet(9) Data Sources(22) Database Lookups(50) Deployment(22) Designer(177) Device(1) DotNetNuke(12) EASE(20) Email(6) Features(101) Firebird(1) Form Builder(14) Globalization and Localization(6) How To(1) Hypermedia(2) Inline Editing(1) Installation(5) JavaScript(20) Kiosk(1) Low Code(3) Mac(1) Many-To-Many(4) Maps(6) Master/Detail(36) Microservices(4) Mobile(63) Mode Builder(3) Model Builder(3) MySQL(10) Native Apps(5) News(18) OAuth(9) OAuth Scopes(1) OAuth2(13) Offline(20) Offline Apps(4) Offline Sync(5) Oracle(11) PKCE(2) Postgre SQL(1) PostgreSQL(2) PWA(2) QR codes(2) Rapid Application Development(5) Reading Pane(2) Release Notes(183) Reports(48) REST(29) RESTful(29) RESTful Workshop(15) RFID tags(1) SaaS(7) Security(81) SharePoint(12) SPA(6) SQL Anywhere(3) SQL Server(26) SSO(1) Stored Procedure(4) Teamwork(15) Tips and Tricks(87) Tools for Excel(2) Touch UI(93) Transactions(5) Tutorials(183) Universal Windows Platform(3) User Interface(338) Video Tutorial(37) Web 2.0(100) Web App Generator(101) Web Application Generator(607) Web Form Builder(40) Web.Config(9) Workflow(28)
Archive
Blog
JavaScript
Tuesday, August 7, 2012PrintSubscribe
Debugging Custom Input Elements

Implementation of input element enhancements may be very simple or demand a relatively complex code. The client input elements are written in JavaScript and may require debugging.

The first instinct of any developer is to write some code, run the app, and try the code in action. Developing and debugging a custom input element with the entire web application project may become unproductive – you need to sign in, navigate to the correct page, select a view to force the custom input element to be activated. Each step takes valuable time.

We recommend creating a test HTML page and debugging the app without touching the actual application.

Let’s consider creating a test HTML page for the Reorder Level Slider input element shown in this screen shot of a live application.

The custom slider input element attached to 'ReorderLevel' data field in a Code On Time web application

If you have followed the instruction from the tutorial then you have the following folder structure under [Documents]\Code On Time\Client folder.

A standalone html page can be used to debug custom input elements without the need to have them run in the actual application

Create the HTML file ReorderLevelDebugger.htm with the following content in Visual Studio or your favorite text editor.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Edtior Debugger</title>
    <link type="text/css" rel="Stylesheet" href="../../../Library/_Client/Stylesheets/_System/_System.css" />
    <script type="text/javascript" src="../../../Library/Data Aquarium/Scripts/_System.js"></script>
    <!-- 
         Important: 
         link the file(s) that you are debugging after the reference to _System.js 
     -->
    <script type="text/javascript" src="ReorderLevelSlider.js"></script>
    <script type="text/javascript">
        // this code is the emulation of steps executed by the client library
        var reorderLevelEditorFactory = null;
        $(function () {
            // create a slider factory object
            reorderLevelEditorFactory = new MyCompany$ReorderLevelSlider()
            // initialize the debugging buttons
            $('#Attach').click(function () {
                reorderLevelEditorFactory.attach($('#Input1').get(), 'Form');
            });
            $('#Detach').click(function () {
                reorderLevelEditorFactory.detach($('#Input1').get(), 'Form');
            });
        });
    </script>
</head>
<body>
    <div>
        Testing the "Reorder Level" slider:
    </div>
    <div>
        <button id="Attach">
            Attach</button>
        <button id="Detach">
            Detach</button></div>
    <div style="border: solid 1px silver; padding: 8px; margin-top: 8px;">
        <input type="text" id="Input1" value="35" />
    </div>
</body>
</html>

The file declares a script block with the global instance of MyCompany$ReorderLevelSlider object. The startup script also assigns click handlers for Attach and Detach buttons declared in the page body. The script header links the system script and stylesheet included by the code generator in every application.

Save the file and open it in the web browser. This is how the page is rendered in Internet Explorer 9 if you click on the file name in Windows Explorer.

Html debugger displayed in Internet Explorer requires user to enable JavaScript execution

You will need to allow execution of JavaScript in the local webpage. This will not be necessary if you preview the page by selecting View in Browser (Ctrl+Shift+W) in the Visual Studio development environment.

The custom input element HTML debugger page with JavaScript enabled

Click Attach button to see the slider attached to the input field.

The slider is attached to the input element when a user clicks on 'Attach' button

Move the slider to try it out.

The custom input element in action

Click Detach  button to see the slider removed.

The custom input element is removed when a user clicks on 'Detach' button

Buttons Attach and Detach invoke the corresponding methods of the “factory” object to associate custom input enhancement with the input field and to have them removed. This is exactly the same pattern of execution by the client library in the live web application.

Monday, August 6, 2012PrintSubscribe
Drag & Drop Everywhere, Validators & Converters

Code On Time web application generator release 6.0.0.32 makes possible true rapid line-of-business application development with complete support for drag & drop and Cut/Copy/Paste of elements in the logical application hierarchy.

The release also introduces and integrated uniform business rules model. The business rules engine of generated applications supports JavaScript, SQL, and C#/Visual Basic business rules. Developers can quickly create validators and converters to perform data validation and conversion on the client, on the database engine tier, or on the application server tier.

Attention: the client script and theme processor now uses the folder [Documents]\Code OnTime\Client to locate the custom files. If you have developed custom scripts then review custom input elements tutorial and move your files to the new location prior to the installation of the update.

The following features, enhancements, and bug fixes are included in this release:

  • Complete drag & drop and Cut/Copy/Paste support on all levels of hierarchies on Pages, Controllers, and User Controls tabs in Project Designer.
     
  • Single-click implementation of generic validators and converters in supported in Project Designer. Developers can extend the generated business rules with custom business logic.
     
  • Page-level and controller-level caching is implemented in Project Designer. This has significantly improved the speed of Project Designer. The projects with the large number of data controllers and pages will see the most improvement with up to 100 times faster execution of many design operations.
     
  • Command node in Project Explorer offers “Reset to Baseline” action. The action will reset the command text to the current baseline version of it.
     
  • Pager in grid views can now be displayed at the top and/or bottom of the view. The default location is the bottom of the view. The property can be configured in page data views.
     
  • The page numbers in the pager now display the index of the first and last pages if the number of pages is greater than 10.
     
  • Action FileName can be handled in business rules to provide a custom file name for a file produced in response to a command specified in CommandArgument of the ControllerAction attribute. Calling UpdateFieldValue method will cause the output file name to change.
     
  • Static lookup items have dedicated hierarchy nodes in Project Explorer.
     
  • Data controller views support Convert to Grid and Convert to Form options in Project Explorer. Form views use categories to group the data fields bound to the view. All other types of views, such as Grid and Data Sheet, do not support categories. The new options are provided to make possible quick conversion of view types.
     
  • The first “select” command is automatically associated with a new view created in Designer.
     
  • JavaScript business rules allow handling the "After" phase for Select|New|AnyOtherAction.
     
  • JavaScript business rules allow handling "Before" phase of "Select" action.
     
  • Application framework blacklists “Code” business rules after the first execution to prevent multiple invocations.
     
  • SQL Business Rules support access to all "flat" properties of the Arguments property. For example, @Arguments_Trigger or @Arguments_CommandName.
     
  • Dragging a foreign key data field to a master data view on the Pages tab will configure a master-detail relationship.
     
  • Dragging a field on a data controller view will create a data field in the view. The data field is placed in the category if the view is a form.
     
  • Renaming a data controller field will change the command text alias of the field and field references in the entire application.
     
  • Application framework has improved speed of command text parsing at runtime.
     
  • Action buttons rendered in 'Row' scope are rendered under the first data column if
    “Action Column” scope is also enabled.
     
  • Fields with custom format strings will result in a "string" elements created in "Export to Spreadsheet" data feeds to prevent the possible data type clash.
     
  • Page is correctly selected in designer when renamed.
     
  • Virtualization node set plugin "Move" will move data fields to view/category and action to action group.
     
  • Node set plugin "Arrange(DataFields|ActionGroups|Actions|Categories|Views)" does not switch the context of the node set.
  • Role-based trimming is performed when automatic reports are created. The fields with "roles" attribute will be automatically trimmed and hidden from the report when needed.
     
  • The tabs are displayed correctly in the form view categories with conditional visibility.
     
  • JavaScript Business Rules processor of client library always replaces field name references with 'this.fieldValue' and 'this.updateFieldValue' methods even if the field is not defined in the active data view.
     
  • Annotation controls are displayed correctly when activated in modal form views.
     
  • DotNetNuke Factory projects will work with rooted and virtual path deployment models of the portal without any changes to the app source code.
     
  • Data access objects will not try to update the read-only fields if a read-only field has been changed.
     
  • Business rule "Script" property is not deleted when other rule attributes are changed.
     
  • Application framework allows overriding YearsBack and YearsForward properties that control the month and quarter filtering.
  • using System;
    namespace MyCompany.Data
    {
        public partial class DateRangeFilterFunction
        {
            public override int YearsBack
            {
                get
                {
                    return 25;
                }
            }
            public override int YearsForward
            {
                get
                {
                    return 5;
                }
            }
        }
    }
     
Wednesday, July 18, 2012PrintSubscribe
Activating Custom Input Controls at Runtime

Client library automatically assigns a calendar behavior to all date-time input elements. This is the example of the calendar displayed next to input elements of Order Date, Required Date, and Shipped Date fields in the Orders form of the Northwind sample.

The example of the built-in calendar provided by the client library.

With a very little effort you can introduce an alternative calendar for all input elements rendered for the fields representing dates.

image

Start by enabling shared business rules in the application settings and re-generate the project.

Create the file [Documents]\Code OnTime\Client\Sample Editors\DatePicker.js and enter this script.

// The "factory" object for DateTime input elements
MyCompany$DatePicker = function () {
}

MyCompany$DatePicker.prototype = {
    // This method is invoked for an input element of a data controller field
    // associated with the editor. Return 'true' if no other editors are allowed.
    attach: function (element, viewType) {
        // hide the "calendar" button next to the input element
        $(element).next().hide();
        // attach a jQuery datepicker to the input element
        $(element).datepicker();
        return true;
    },
    // This method is invoked by the client library before the input element
    // of the field is destroyed. Return 'true' if no other editors are allowed.
    detach: function (element, viewType) {
        // detach the datepicker from the input element
        $(element).datepicker('destroy'); 
        return true;
    }
}

Start the code generator and the script will be integrated in the client library.

Activate Project Designer and click Browse to cause the application to be generated. Hit the browser Refresh button to ensure that the latest version of the client library is downloaded.

Switch to Project Designer and click  Develop button on the toolbar. Visual Studio or Visual Web Developer will start. Open ~/App_Code/Rules/SharedBusinessRules.cs(vb) file and enter the following code.

C#:

using System;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using MyCompany.Data;

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

        protected override void VirtualizeController(string controllerName)
        {
            NodeSet().Select("field[@type='DateTime']").Attr("editor", "MyCompany$DatePicker");
        }
    }
}

Visual Basic:

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

Namespace MyCompany.Rules
    
    Partial Public Class SharedBusinessRules
        Inherits MyCompany.Data.BusinessRules

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

        Protected Overrides Sub VirtualizeController(controllerName As String)
            NodeSet().Select("field[@type='DateTime']").Attr("editor", "MyCompany$DatePicker")
        End Sub
    End Class
End Namespace

The methods of the shared business rules class will adjust the definition of data controllers with the help of virtualization node sets. The method VirtualizeController selects all date-time fields and assigns the custom editor at runtime.

Save the file and browse the application from the generator or directly in development environment. Date-time input elements in the entire app are now featuring a new calendar based on jQuery UI date picker.

Make sure to refresh the app when the first page is displayed in the web browser to ensure that the latest version of the custom scripts has been loaded.

Virtualization node sets allow easy assignment of custom input editors to the specific data controller fields at runtime.