Code On Time: Cloud

Blog

Cloud

Monday, October 8, 2012Print Subscribe

The Product Browser example explains how to create a user control that takes advantage of the application server built in a web app created with Code On Time. The scope of this example is to demonstrate reading the app data with REST requests with a custom JavaScript. The example also uses jQuery library integrated in the generated web apps.

Most custom user interface extensions will need to update, insert, and delete data. Create, Read, Update, and Delete operations are also known as CRUD. A complete example of a standalone Product Catalog Manager is implementing a Cross-Domain CRUD.

If a custom user control is created in a web app, then there is no need for cross-domain AJAX requests. Standard JSON requests can be executed with explicitly defined HTTP methods POST, GET, PUT, and DELETE to indicate the purpose of an AJAX web request.

Enabling Access to Products, Suppliers, and Categories

Three data controllers are required to implement the Product Catalog Manager. The data controllers Products, Categories, and Suppliers must explicitly allow REST requests. The application server will deny any web requests if data controllers are not configured accordingly.

Select Products, Suppliers, and Categories data controllers in Project Designer and enter the following in its Representational State Transfer (REST) Configuration property for each controller:

Property	Value
Representation State Transfer (REST) Configuration	Uri: . Users: *

Creating a User Control

Create a custom user control following instructions from the Product Browser example and replace the markup of a the user control with the example from the Source Code section below.

Browse to the page of a running web app that contains the user control. You will see the following:

Note that if you are accessing the page without singing in, then you will see a browser prompt for user name and password. The static link to the list of suppliers will force the application server to issue an identity challenge.

<script type="text/javascript" 
    src="../appservices/Suppliers?_sortExpression=CompanyName&_instance=SupplierData">
</script>

If you do not wish to have a static link to suppliers then dynamically populate SupplierID list following the pattern shown in the implementation of loadCategories method.

loadCategories: function () {
    $.ajax({
        url: this.basePath() + '/Categories?_sortExpression=CategoryName',
        dataType: 'json',
        cache: false,
        success: function (data) {
            $.each(data.Categories, function (index, category) {
                $('<option>').text(category.CategoryName)
                .attr('value', category.CategoryID).appendTo($('#CategoryID'));
            })
        }
    });
}

Try updating, inserting, and deleting data.

A new product is created by issuing an PUT request to the application server of a web app.

An existing product is deleted by issuing a DELETE request to the application server of a web app.

Source Code

The ajax requests are using a relative path to access the application server. Method ProductManager.basePath() return the path.

Notice the use of “json” in the “dataType” parameter of ajax requests. Also the nature of the CRUD operations is explicitly expressed by the “type” of the requests.

<%@ Control AutoEventWireup="true" %>
<!-- this tag is needed to enable jQuery IntelliSense only -->
<script src="../Scripts/_System.js" type="text/javascript"></script>
<!-- the user interface of the control -->
<script type="text/javascript" 
    src="../appservices/Suppliers?_sortExpression=CompanyName&_instance=SupplierData">
</script>
<script type="text/javascript">
var ProductManager = {
    // Returns the url of the application server of a demo web app.
    basePath: function () { return '../appservices'; },
    // Loads the list of categories requested from the app server via ajax request.
    loadCategories: function () {
        $.ajax({
            url: this.basePath() + '/Categories?_sortExpression=CategoryName',
            dataType: 'json',
            cache: false,
            success: function (data) {
                $.each(data.Categories, function (index, category) {
                    $('<option>').text(category.CategoryName)
                    .attr('value', category.CategoryID).appendTo($('#CategoryID'));
                })
            }
        });
    },
    // Populate suppliers from the list retrieved by the second <script> element.
    loadSuppliers: function () {
        $.each(MyCompany.SupplierData.Suppliers, function (index, supplier) {
            $('<option>').text(supplier.CompanyName)
                .attr('value', supplier.SupplierID).appendTo($('#SupplierID'));
        })
    },
    // Shows a list of products in <select> element
    showProductList: function () {
        var query = '?_sortExpression=ProductName&_q=' + encodeURIComponent($('#QuickFind').val());
        $.ajax({
            url: this.basePath() + '/Products' + query,
            cache: false,
            dataType: 'json',
            success: function (data) {
                var selectedValue = $('#ProductList').val();
                $('#ProductList option').remove();
                $.each(data.Products, function (index, product) {
                    $('<option>')
                        .text(product.ProductName + ' / ' + product.CategoryCategoryName)
                        .attr('value', product.ProductID).appendTo($('#ProductList'));
                });
                $('#ProductList').val(selectedValue);
                $('#ProductListPanel').show();
            }
        });
    },
    // Shows a form with product details,
    showProductDetails: function (productId) {
        if (productId == null) return;
        $('#ProductSearchPanel').hide();
        $('#DeleteButton').show();
        $.ajax({
            url: this.basePath() + '/Products/editForm1/' + productId,
            cache: false,
            dataType: 'json',
            success: function (product) {
                $('#ProductDetailsPanel').show();
                $('#ProductID').attr('value', product.ProductID);
                $('#ProductName').attr('value', product.ProductName).focus();
                $('#SupplierID').attr('value', product.SupplierID);
                $('#CategoryID').attr('value', product.CategoryID);
                $('#QuantityPerUnit').attr('value', product.QuantityPerUnit);
                $('#UnitPrice').attr('value', product.UnitPrice);
            }
        });
    },
    // Returns back to the search mode.
    backToSearch: function () {
        $('#ProductDetailsPanel').hide();
        $('#ProductSearchPanel').show();
        $('#ProductList').focus();
    },
    // Refreshes the search result.
    refreshSearch: function () {
        this.backToSearch();
        this.showProductList();
    },
    // Formats a URI of a product
    createProductUrl: function (requestType) {
        if (requestType == 'POST')
            return this.basePath() + '/Products/createForm1';
        return this.basePath() + '/Products/editForm1/' + encodeURIComponent($('#ProductID').val());
    },
    // Creates an object with the properties retrievd from the input fields 
    // of the "ProductDetails" form.
    collectFieldValues: function () {
        return {
            ProductID: $('#ProductID').val(),
            ProductName: $('#ProductName').val(),
            SupplierID: $('#SupplierID').val(),
            CategoryID: $('#CategoryID').val(),
            QuantityPerUnit: $('#QuantityPerUnit').val(),
            UnitPrice: $('#UnitPrice').val()
        };
    },
    // Deletes a products.
    deleteProduct: function () {
        if (!confirm('Delete?')) return;
        $.ajax({
            url: this.createProductUrl('DELETE'),
            dataType: 'json',
            type: 'DELETE',
            data: ProductManager.collectFieldValues(),
            success: function (result) {
                if (result.errors)
                    alert(result.errors[0].message);
                else
                    ProductManager.refreshSearch();
            }
        });
    },
    // Shows the product form with blank values.
    newProduct: function () {
        $('#ProductSearchPanel').hide();
        $('#DeleteButton').hide();
        $('#ProductDetailsPanel').show();
        $('#ProductID').attr('value', null);
        $('#ProductName').attr('value', 'New Product').focus().select();
        $('#SupplierID').attr('value', null);
        $('#CategoryID').attr('value', null);
        $('#QuantityPerUnit').attr('value', null);
        $('#UnitPrice').attr('value', null);
    },
    // Saves a product. If there is no value in the #ProductID hidden field then
    // a new product is created by "POST" request. Otherwise an existing product
    // is updated with "PUT" request.
    saveProduct: function () {
        if (!confirm('Save?')) return
        var requestType = $('#ProductID').val() != '' ? 'PUT' : 'POST';
        $.ajax({
            url: this.createProductUrl(requestType),
            dataType: 'json',
            type: requestType,
            data: ProductManager.collectFieldValues(),
            success: function (result) {
                if (result.errors)
                    alert(result.errors[0].message);
                else {
                    if (requestType == 'POST')
                        alert('ID of the new product is ' + result.ProductID);
                    ProductManager.refreshSearch();
                }
            }
        });
    },
};
$(document).ready(function () {
    // pre-populate the drop down lists of categories and suppliers
    ProductManager.loadCategories();
    ProductManager.loadSuppliers();
    // attach event handlers to buttons
    $('#ProductListPanel,#ProductDetailsPanel').hide();
    $('#FindButton').click(function (e) {
        e.preventDefault();
        ProductManager.showProductList();
    });
    $('#ShowDetailsButton').click(function (e) {
        e.preventDefault();
        ProductManager.showProductDetails($('#ProductList').val());
    });
    $('#BackToSearchButton').click(function (e) {
        e.preventDefault();
        ProductManager.backToSearch();
    });
    $('#NewButton').click(function (e) {
        e.preventDefault();
        ProductManager.newProduct();
    });
    $('#SaveButton').click(function (e) {
        e.preventDefault();
        ProductManager.saveProduct();
    });
    $('#DeleteButton').click(function (e) {
        e.preventDefault();
        ProductManager.deleteProduct();
    });
    $('#QuickFind').focus();
});
</script>
<style type="text/css">
    body, button, input, select
    {
        font-family: Tahoma;
        font-size: 8.5pt;
    }
   
    #QuickFind
    {
        width: 280px;
    }
    
    #ProductList
    {
        width: 350px;
        height: 208px;
        margin-bottom: 4px;
    }
    
    #FindButton
    {
        width: 60px;
    }
    
    #ProductListPanel
    {
        margin-top: 4px;
    }
    
    .Field
    {
        padding-bottom: 4px;
    }
    
    #ProductDetailsPanel
    {
        margin-top: 4px;
        padding: 8px;
        border: solid 1px silver;
        display: inline-block;
    }
    
    .Field label
    {
        display: block;
        color: green;
    }
    
    .Field input
    {
        width: 300px;
    }
</style>
<div>
    <div id="ProductSearchPanel">
        <input id="QuickFind" type="text" />
        <button id="FindButton">
            Find</button>
        <div id="ProductListPanel">
            <select id="ProductList" size="5">
            </select>
            <div>
                <button id="ShowDetailsButton">
                    Show Details</button>
                <button id="NewButton">
                    New Product</button>
            </div>
        </div>
    </div>
    <div id="ProductDetailsPanel">
        <input id="ProductID" type="hidden" />
        <div class="Field">
            <label for="ProductName">
                Product Name:</label>
            <input id="ProductName" />
        </div>
        <div class="Field">
            <label for="SupplierID">
                Supplier Company Name:</label>
            <select id="SupplierID">
            </select>
        </div>
        <div class="Field">
            <label for="CategoryID">
                Category Name:</label>
            <select id="CategoryID">
            </select>
        </div>
        <div class="Field">
            <label for="QuantityPerUnit">
                Quantity Per Unit:</label>
            <input id="QuantityPerUnit" />
        </div>
        <div class="Field">
            <label for="UnitPrice">
                Unit Price:</label>
            <input id="UnitPrice" />
        </div>
        <div>
            <button id="BackToSearchButton">
                Back To Search</button>
            <button id="SaveButton">
                Save</button>
            <button id="DeleteButton">
                Delete</button>
        </div>
    </div>
</div>

Labels: Application Factory, Business Rules/Logic, Cloud, JavaScript, REST, User Interface, Web Application Generator

Friday, March 30, 2012Print Subscribe

Azure Factory

With the release of Windows Azure, Microsoft has provided a great cloud database, storage, and computing service platform. Windows Azure offers many benefits, such as guaranteed 99.95% uptime, automatic OS and service patching, integrated network load balancing, and easy scaling.

While the Windows Azure cloud may offer the perfect platform to deploy your next web application, you still need to build this application. This is where Code On Time’s Azure Factory comes in. All you have to do is paste in your SQL Azure database connection string, and hit Generate. In a minute, your advanced web application will start in your default browser, complete with sorting, adaptive filtering, reporting, charts, and much more. Hit Publish, and the application will be packaged. Upload the published deployment package to Windows Azure, and within minutes you’ll have your app running in the cloud.

Need to add more features and customize your app? Just use the easy to use Designer to make necessary changes to the logical definition of the application. While no coding is needed to make a great app, you can always open the source code in Visual Studio and change it to precisely fit your requirements.

The following article will explain how to generate and deploy an Azure Factory application. View our learning system if you need help setting up a Windows Azure account, creating a database server, or creating a database using SQL Azure tools.

Generating the Azure Factory Project

Launch the web application generator, and create a new project. Choose Azure Factory.

Give this project the name of “AzureFactory”. Pick the programming language of your choice. Press Create to create the project.

On the next page, you can specify your namespace. We’ll leave the default of “MyCompany” and continue to the next page of the wizard by pressing Next.

This page requires you to specify a database connection. Click on the “…” button next to the Connection String field to configure the string.

In the Server field, enter the database’s Fully Qualified DNS Name. This can be found in the Properties of the server when using Windows Azure Management Portal.

Enter your server username and password.

If you already have an SQL Azure database, then enter it’s name in the Database field. If you don’t have a database, you can quickly create one using the web application generator. The next few steps explain how to create a sample Northwind database.

In the Database field, write “Northwind”. Press the Create button to create the database. Press Yes to confirm creation of the database.

You will be notified that the database has been created. Press OK to close the notification, and select Northwind from the Sample Tables dropdown. Press Install to install the Northwind sample into the database, and press Yes to confirm.

Once complete, you will be notified. Press OK to close the notification.

The next steps explain configuration of ASP.NET Membership and Session State management that apply to any database.

Let’s add ASP.NET Membership to this database. Under Membership, press Add. Press OK to confirm installation.

Once complete, press OK to close the notification.

By default, Azure Factory applications are configured to use two extra-small server instances in the cloud. If you use multiple instances, then Session State management must be included in the application. Under Session State, press Add. Press OK to confirm the installation.

Press OK to close the notification, and press OK one more time to save the connection string. Press Next twice to get to the Reporting page.

Check the box to enable reporting, and keep pressing Next to reach the Theme page.

Let’s choose the Azure theme. Select Azure from the list.

Hold down Shift key, and press Next. This shortcut will take you to the Summary page. Press the Generate button.

Wait until the generator finishes, and your default browser will open with your new web application. While the application is running on your computer, the database is located in the cloud. You can log in and start using the app immediately.

Deploying the Web App

It’s time to deploy the app to Azure. Go back to the generator, and click on the project name. Press Publish.

The generator will package the web application and create the files necessary for deployment. A Windows Explorer screen will open and display the location of the files.

Log in to your Windows Azure Management Portal, and switch to Hosted Services, Storage Accounts & CDN section in the bottom left corner. In the folders, click on Hosted Services. Select your subscription, and press New Hosted Service on the ribbon.

Use the following settings for your new hosted service:

Choose a subscription	3-Month Free Trial
Enter a name for your service	AzureFactory
Enter a URL Prefix for your service	AzureFactory (if not available, use something else)
Choose a region or affinity group	Anywhere US (or your closest region)
Deployment options	Deploy to stage environment
Deployment name	AzureFactory
Package location	~\MyDocuments\CodeOnTime\Publish\Azure Factory\AzureFactory\CloudApp.cspkg
Configuration file	~\MyDocuments\CodeOnTime\Publish\Azure Factory\AzureFactory\ServiceConfiguration.cscfg

Press OK, and Windows Azure will start the deployment process. This step may take 10-15 minutes. Once the status of the deployment changes to Ready, use the link found under Properties. You will be taken to the fully functional website running in the cloud .

If you look at the URL, you will notice that it uses the ID of the deployment, not the requested DNS Name. This is because the deployment is a staging deployment. You can go back to the management portal, and choose Swap VIP to change it into a production deployment. Now you can use the DNS Name you specified during creation of the hosted service.

When you are ready to deploy a new project revision, create a new staging deployment. Test the new deployment in the cloud. If everything is working as expected, then swap the virtual IP address of the staging deployment with the production one. Click Swap VIP button on the Management Portal ribbon to do so.

When VIP swapping has finished, the previous application revision will become a staging deployment. Shut it down if you don’t need it. Continue upgrading staging deployment with the new revisions of the application, and swapping them later with production.

Labels: Application Factory, Azure, Cloud, Deployment, Web Application Generator

Tuesday, January 31, 2012Print Subscribe

Roadmap 2012

Code On Time has expanded its rapid application development capabilities during the year of 2011.

In minutes you can build database web applications that are ready for deployment to shared or dedicated hosting server. We now support Microsoft SQL Server, Oracle, MySQL, and SQL Anywhere.

A new exciting cloud platform called Microsoft Windows Azure attracts the attention of developers and business managers looking to cut deployment costs down and make deployment of web application simpler. Generate an Azure Cloud solution from your SQL Azure database. The solution includes a Web Role and class library implementing a web site with navigation system, role-based security, membership manager, built-in data export, reporting, and much more. Have it online in 15 minutes.

Many line-of-business web applications benefit from tight integration with web content management systems. We now offer two options that allow to take advantage of popular content management systems DotNetNuke and Microsoft SharePoint Foundation 2010.

DotNetNuke Factory creates application pages as controls with data views incorporated in a DotNetNuke module. The registered module can be configured by end users. This particular CMS is perfect for Internet-facing web applications.

SharePoint Factory creates a collection of application pages implemented as user controls, and packages them for deployment as a Microsoft SharePoint 2010 Feature with a single Web Part. Use this type of project for Intranet websites.

We are preparing the new http://codeontime.com website, complete with high quality search and built-in documentation engine. We expect to launch the new site in a few weeks from now. The new documentation section will be cross-referenced in the Designer.

Our Code On Time team is working diligently to further the appeal of our web application generator. We would like to share the 2012 roadmap and explain the direction our product is taking.

The following upcoming features are presented in the approximate order of delivery. We will continue releasing bug fixes and introduce various product enhancements that are not listed in the roadmap. Updates will continue being delivered monthly.

Sync Server

Team development will become simple and hassle-free with the release of Sync Server. This is a cloud service from Code On Time designed to support groups of users working on the same project. Web application generator will feature Commit, Update, and Rollback actions to allow merging of the change logs created in the application Designer.

This tool will not replace existing powerful source control managements systems such as SVN or TFS. The sole purpose of the tool is to make the maintenance of Code On Time designer files as transparent and carefree as possible. Developers will be able to customize any part of the project and share their work with a push of a button.

Native Import of CSV Files

Shared hosting servers and restrictive host environments such as Windows Azure and Microsoft SharePoint Foundation make it impossible to use the Import feature available in the generated applications.

The current implementation relies on Microsoft Access Database Engine to process the submitted CSV, XLS, and XLSX files. It is not always possible to have them installed in the hosting environment.

We will offer a native reader of CSV files that will be embedded in the source code of generated application in Premium and Unlimited editions of the product.

Tree View

There is a partial implementation of “Tree” view in the current library. The implementation will be completed and become an official feature of the product.

Drag & Drop in Project Explorer

We have recently introduced the Project Explorer displayed alongside the Project Designer. The hierarchy of web application pages and data controllers allow easy access to the properties of various elements of an application. The hierarchies offer a holistic view of an application.

A full drag & drop manipulation of nodes in the hierarchies will allow easy reordering and changes in the composition of the project.

For example, you will be able to drag and drop “page” nodes to quickly change the navigation system of an application. Dragging of data fields will allow quick changes to the data presentation.

We will also allow Alt and Ctrl keys to affect the outcome of drag and drop actions. For example, one can imagine dragging a “view” node while keeping Ctrl pressed and dropping it on the parent node in the hierarchy. The outcome of such action may be creation of a “duplicate” view. We hope to work with the community to develop useful drag and drop actions.

“SELECT” Data Using Stored Procedures and Web Services

Code On Time web applications dynamically compose SQL SELECT statements to efficiently retrieve data. The generated application incorporates server side access control rules, user-defined filters, and sort order in the single SELECT expression. The application uses parameters to incorporate the user provided values.

This works great in many situations. Sometimes you may need a complex business logic to produce a data set presented to a user. There may be a stored procedure or a call to an external web service that produces data.

We will allow various levels of control to execute code before and after the data is processed. Developers will be able to supply a virtual dataset if needed. We will also support native “virtualization” for stored procedures.

Business Rules in Project Explorer

Code On Time web applications offer a simple and powerful approach to the separation of business logic from the user interface. Developers create business rules for this purpose. Business rules are implemented as classes. The classes contain methods adorned with ControllerAction, AccessControl, and RowBuilder attributes. These attributes allow the methods to participate in the application lifecycle.

Project Explorer will automatically parse the source code of all available business rules and match them to action nodes. Nodes of type controller and data view will feature Business Rules child node that will provide a summary of detected methods and will also allow easy creation of business rules. Methods and arguments will be automatically inserted in the source code. We will also allow selecting a purpose of the method. The boilerplate method implementation will reference the web resources explaining how a particular task can be accomplished in a Code On Time application.

Business rules are generated first time only. Customization will be preserved between the code generation sessions. New methods will be injected directly in the existing business rules. If a class implementing the business rules does not exist then a new class will be created.

EASE: My Account

Imagine that you are creating a web application to support a non-profit organization.

There are application users responsible for administration of the site. Event organizers will suggest the events supporting the cause of the organization. There are volunteers willing to sign up to help in organizing the events. There are donors who may wish to contribute financial resources.

Code On Time web applications offer a self-service sign up. Users create their own accounts with ease, which works great and requires minimal administration of the process. Users can login immediately. The application must ensure that the role of a user account is known to allow further access to the application pages. User “a” may wish to become a donor. User “b” would like to suggest an event. User “c” is burning with desire to volunteer.

Generated web applications will implement a class invoked to determine if a user account requires additional configuration when a page is accessed. Developer will have the power to make a determination and force the appropriate user configuration page presented in the browser. “My Account” link on the task bar will allow programmatic selection of the user configuration page.

This feature is a component of EASE (Enterprise Application Services Engine).

EASE: Dynamic Access Control List

Suppose you have created a successful line-of-business application for your client. Another client gets on board – things cannot be any better. Soon you discover that maintaining two clients with the same code base is very difficult. Complexity escalates quickly as you gain more and more customers.

If you have defined access control rules for one client then most likely your rules with have to be expanded to accommodate the other clients as well. Code On Time makes it easy, but the static nature of the access control rules will require frequent re-deployment of the application and possibly database changes.

Dynamic Access Control List will introduce a custom set of tables in the database of your application to support access control rules defined at runtime. The management tool will be built into your web application. Administrators will be able to define access control rules and assign them to roles and individual users.

This feature is a component of EASE (Enterprise Application Services Engine).

Code On Time Tools for Excel

Project Explorer makes it easy to have a bird-eye hierarchical view of your project. Many developers and business users feel more comfortable interacting with the application configuration setting presented in Microsoft Excel spreadsheet.

Code On Time Tools for Excel will provide an alternative to the built-in Designer. Custom ribbon tab will offer access to Code On Time projects. It will be possible to import all elements of a project into separate sheets and make changes to them en-masse. Ribbon controls will allow incorporating changes to the project designer log files.

Mobile Web Applications

Code On Time web applications display well in modern touch phones and tablets. However, the form factor of the web applications is designed to work best in the desktop browsers. The user interface is mouse-driven.

The unique design of Code On Time web applications allows seamless replacement of the client JavaScript library to accommodate new presentation paradigm. Upcoming releases of Code On Time will automatically link the mobile client library when touch screen phones and tablets are detected and render web applications accordingly.

There will be no need to change the existing applications or develop additional “mobile” pages that must be kept in sync with the desktop counterparts.

This feature will be available in Unlimited edition.

Ribbon Action Group

Recently released SharePoint Factory practically calls for a new action scope “Ribbon” to be supported.

New action scope will be available to expose the data controller actions on the tabs of the SharePoint ribbon.

We will also incorporate the SharePoint-style ribbon in other types of projects to offer this popular feature of Microsoft Office in the generated web applications that are not based on Microsoft SharePoint. You will find an example of an action group scope here.

EASE: Custom Membership Providers

Microsoft has introduced ASP.NET Membership to enable quick creation of sophisticated user and role management in the web applications. Code On Time makes it easy to take advantage of this standard feature. Generated web applications offer built-in Membership Manager, the visual tool that works on top of ASP.NET Membership.

Some developers do not trust Microsoft to do the job right and rely on their own tables and plumbing to handle the security. Full support for ASP.NET Membership providers is built in the ASP.NET.

Code On Time will offer automatic generation of custom membership providers directly from the custom database tables.

This feature is a component of EASE (Enterprise Application Services Engine).

A restricted version of custom membership provider will be available in all product editions if a web application is generated from SQL Compact, Microsoft Access, or DB2 database. This will apply to data sources that do not offer a standard ASP.NET membership provider.

Data Source: SQL Compact

Code On Time will support generation of web application from Microsoft SQL Compact databases.

Data Source: Microsoft Access

Code On Time will support generation of web application from Microsoft Access databases.

Data Source: DB2

Code On Time will support generation of web application from IBM DB2 databases.

Binary Fields: Upload When Inserting Records

Web applications generated with Code On Time allow direct upload/download of binary content to and from the binary columns of existing table rows. It is not possible at this time to upload the binary content when a new row is created. The upload process streams the data straight to the database and a physical row has to exists for this to happen.

The new record does not exist in the database at the time when an end user selects a file to upload. The same limitation applies to binary content stored externally.

The upcoming revisions of the application framework and client library will allow selecting the binary files when a new record is created. The application framework will not upload the files instantly. Instead the upload will start when the database row has been created successfully.

Binary Fields: File System Adaptor

The web application generator will produce the “adapter” class that will make it easy to direct the uploaded content to the external file system folders. No programming will be required.

Binary Fields: Azure Adapter

The web application generator will produce the “adapter” class that will make it easy to direct the uploaded content to the Windows Azure Storage. No programming will be required.

Binary Fields: Amazon S3 Adapter

The web application generator will produce the “adapter” class that will make it easy to direct the uploaded content to the Amazon S3 storage. No programming will be required.

Binary Fields: Multi-File Upload

Code On Time web applications will support optional multi-file uploading with a progress indicator.

EASE: Workflow Register

Workflow Register will complement the runtime capabilities of generated web applications. This feature will join the Membership Manager and Dynamic Access Control List.

If you are developing an application that services multiple customers, then a common requirement is to allow customization of the user interface according to the needs of each customer. Workflow Register will bring elements of Code On Time Designer to the generated applications. End users will be able to create new virtual pages, data views, and actions groups.

This feature is a component of EASE (Enterprise Application Services Engine).

View Type: Calendar

If your dataset has a date column then it is not a bad idea to see the records in calendar format. This is precisely what we intend to do.

The new view type will render data in a calendar format and will behave similar to the grid view for all intents and purposes.

EASE: Dynamic Web Content Management System – Site Builder

Search Engine Optimization and web content management may not be on your mind when you are creating a line-of-business web application. If your software-as-a-service solution is ready for production then the next step is to start a marketing campaign.

You will likely seek a 3rd party solution such Wordpress or Office 365. You do have the option of incorporating your software in the popular content management systems with DotNetNuke Factory and SharePoint Factory.

If none of the above options are appealing then Code On Time will have another option for you. Built-in site builder will allow creation of virtual pages within your own application that are seamlessly integrated in your web application. No 3rd party software will be required.

This feature is a component of EASE (Enterprise Application Services Engine).

View Type: Rollup

We will deliver a new view type that will present a variation of data sheet view with the ability to collapse the data rows. The view will differ from the data sheet view. It will behave more inline with traditional spreadsheet style of presentation. The overflow data in the cells will not wrap to the next line and will stay hidden.

View Type: Map

Location presentation is easy in modern web development thanks to mapping solutions from Google and Microsoft. We will offer a new view type to present the dataset on the map.

Cloud On Time

We hope to end this year with the launch of http://cloudontime.com. The hosted version of Code On Time with ability to create tables will require zero software on the computer. The service will be subscription-based.

Developers will be able to start the project in the cloud and optionally migrate to a custom version of the cloud app that will be under their full control with the help of Cloud Factory project.

1-to-1 Entities

A common database design practice is to use 1-to-1 entities.

For example, you may implement the Person table that provides the base shared columns LastName and FirstName for tables Student and Teacher. Both the Student and Teacher tables have PersonID column that allows inclusion of common attributes.

Code On Time does not recognize such relationships and generates the master-detail page where Person is the master view and Student and Teacher are detail views.

The developer’s intent is to have the two independent pages and two controllers that match Student and Teacher. Both controllers must incorporate the personal information (LastName and FirstName) as if it is defined in the base tables.

We will offer a special mapping area to identify the 1-to-1 entities and will generate the code to handle the distributed nature of the data in such relationships.

Labels: Cloud, EASE, Web 2.0, Web Application Generator