Web Site Factory Preview 2

The preview #2 of the Web Site Factory premium project is now online.

You can access the sample application without integrated membership at http://dev.codeontime.com/demo/websitefactory1.

You can access the sample application with integrated membership at http://dev.codeontime.com/demo/websitefactory2.

Both version of application were generated by simply pointed the Code OnTime Generator to the Northwind database. The code generation process takes less than a minute. The result is a spectacular ASP.NET/AJAX application with complete source code and no external dependencies.

Features

You will immediately notice a dramatic new styling of generated application. We have modeled the user interface after increasingly popular Microsoft SharePoint. The generated code is not a Microsoft SharePoint application but it sure looks like one! 

The user interface is entirely based on CSS and can be changed to whatever you like.

AJAX-enable and highly responsive user interface is consistent across all major browser, which you can see in the screenshots below.

The user interface features new multi-level menus with unlimited number of levels. The menus automatically detect page boundaries and reposition themselves appropriately. Full keyboard support is provided.

All pages are fluid and are automatically taking over the entire available browser window or scroll in the page is too long.

Optional integrated membership manager gives you a robust user and role management tool.

An AJAX-enabled context summary is displayed on the side bar when a record is selected. Automatic “See Also” box is included on the side bar to simplify navigation.

The side bar context senses when any part of it obstructed due to page scrolling and bring itself into view.

On the picture below you can see a supplier record in edit mode.

Now we have scrolled the page to the bottom and the side bar content has reacted appropriately.

 

Conclusion

The preview #2 is based on a simple page layout. One database table is presented per page.

The next preview will demonstrate standard variations of the user interface with master-detail relationships.

Web Site Factory Preview 1

We are diligently working on delivering the best possible code generation premium projects for ASP.NET/AJAX, namely Web Site Factory and Web Application Factory.

A significant number of new features were introduced and we have decided to spend a little bit more time to polish both projects. The final release has been postponed until November 2nd, 2009.

Meanwhile we would like to share a preview of the Web Site Factory premium project:

http://dev.codeontime.com/demo/WebSiteFactory1

The code has been generated straight from the Northwind database and uses a simple page layout.  The simple layout presents one view on a single page per database table.

We will release more previews in the coming days to illustrate all available page layouts.

It will be possible to modify the default page layouts and create new pages in Code OnTime Designer.

The demo features the latest Data Aquarium Framework with a new menu engine and faster rendering.

Please post your comments.

Conditional Visibility in Forms

Data Aquarium Framework supports declarative conditional visibility of fields and field categories in form views.

Conditional Visibility of Fields

Here is a snippet of the data field controller used in Code OnTime Designer that controls visibility of the Formula field if the field is marked as computed.

<category headerText="General" >
    <description><![CDATA[ Specify field name, type, and data properties of the field.]]></description>
    <dataFields>
        . . . . . 
        <dataField fieldName="Computed">
            <headerText>The value of this field is computed at run-time.</headerText>
        </dataField>
        <dataField fieldName="Formula" columns="50" rows="5">
            <visibility>
                <expression type="ClientScript" test="[Computed]==true"/>
            </visibility>
        </dataField>
        <dataField fieldName="OnDemand"/>
    </dataFields>
</category>

The visibility expression test is written in JavaScript. The expression test can refer to the names of the fields defined in the view. The field referenced must be incased in square brackets.

The expression test is evaluated on the client whenever the field values are changed. Evaluation does not cause the server post-back.

The following screenshots show the form before and after the computed field checked.

Conditional Visibility of Categories

The following snippet from the the same data controller shows visibility expression for a field category.

<category headerText="Lookup">
    <dataFields>
        <dataField fieldName="ItemsStyle"/>
        <dataField fieldName="ItemsDataController"/>
        <dataField fieldName="ItemsDataValueField"/>
        <dataField fieldName="ItemsDataTextField"/>
        <dataField fieldName="ItemsNewDataView"/>
        <dataField fieldName="ContextFields"/>
    </dataFields>
    <visibility>
        <expression type="ClientScript" test="[Type] != 'Byte[]' &amp;&amp; [Type] != 'Object' &amp;&amp; [OnDemand] != true" />
    </visibility>
</category>

The JavaScript expression reads as follows:

[Type] != 'Byte[]'  &&  [Type] != 'Object' && [OnDemand] != true

If the value of field Type is not equal to Byte[] or Object and the field is not OnDemand then the category of fields is visible.

The next screenshot shows the visible Lookup field category.

Conclusion

The visibility expressions can be defined directly in the data controller files. The upcoming update to Code OnTime Designer will allow easy modifications of the visibility expressions.

Learn by Example

Discover how code generators can help you to learn web development faster.

Learning to program web applications might seem like a brilliant idea. With hundreds of educational repositories on the Internet and many companies giving away tools practically for free, it seems that you can easily build the next Facebook. However, once one starts to dig deeper, they realize that it isn’t quite what it seems. With the Internet being such a hodgepodge of information, the student has a difficult time sorting it all out. Many go about copying and pasting code snippets found on the Internet, and assembling them into an application. Other alternatives are to pay for costly educational programs that teach you the basics.  None of these are great options for starting your next killer app.

People learn by example. The Internet provides tons of examples of all types of code. However, this code is not designed to work together. It’s like building something with different parts. A head of a donkey, the body of a lion, and the legs of an antelope were not designed with compatibility in mind. You need an integrated example in which all parts are working together perfectly, and organized in a thoughtful way. Instead, get a quality code generator. Point it to your database, choose your settings, and it will generate a complete framework and application in minutes, doing what many programmers take years to learn. Through examination of the generated code, many secrets of the trade can be learned, and methods of creating database applications can be acquired.

Let’s say you want to build a customer relationship management (CRM) database web application. This requires you to display customers, contacts, addresses, and activities, among others. You will need to provide means to sort and filter, display the records, and show a record detail view. Search for any of these on the Internet. For example, google “display grid of records ASP.NET”, and you will get nearly a quarter million results. How can you know which one is right for you? Let’s use a code generator. First, create a database for your CRM. Then, point your code generator to the database, select the desired options, and start code generation. Shortly, you will have the perfect instructional material. Some code generators provide you with the bare basics and create a simplistic web application. Others, like Code OnTime’s ASP.NET Code Generator, can create a highly sophisticated and thought-out application, complete with sorting and filtering, AJAX integration, reporting, and many other great features. It is also very easy to maintain. The generated professional-grade web application can impress the best programmers. The entire source code is available to examine and modify, and can teach you the most advanced methods of creating such an application.

The generated code has the advantage of being designed to work together, unlike “cut and paste” samples, which can be unwieldy and may not integrate successfully. This code doesn’t need to be used in your final project, and can be entirely thrown out once you’ve learned what you can from it. Or, you can decide to borrow some sections of the code for your own application, or just keep the whole thing and build your code on top of it.

Additionally, you can impress your friends and coworkers with a professional looking web application, and tell them about the great skills you acquired over the weekend just before the football game.

Calculated Fields Revisited

The upcoming update of Data Aquarium Framework will include additional support for field formulas to simplify creation of calculated fields.

The current available options are listed here:
http://blog.codeontime.com/2009/05/calculated-fields-in-data-controllers.html

The update will allow for a more flexible and much simpler solution. Here is an example of an actual calculated formula for OrderDetails.xml data controller:

<field name="Total" type="Currency" allowNulls="true" isPrimaryKey="false" readOnly="true" label="Total" computed="true">
  <formula>"OrderDetails"."UnitPrice" * "OrderDetails"."Quantity" * (1 - "OrderDetails"."Discount")</formula>
</field>

The “computed” attribute will enable the formula. The formula is an SQL expression that is embedded into final SELECT statement. You can create formulas for standard generated fields and quickly introduce new fields without the need to modify the original command or creating views.

Code OnTime Designer will fully support field formulas.

Eliminate the Grisly Problems of Project Estimation

See how a code generator can help reduce the headaches of Project Estimation and Planning.

The Project Manager’s job is to produce a project estimate, the most complicated step of any project. Project estimation forces project managers to deal with the unknown, making estimation difficult. Merely guessing off intuition is not the best solution. Many managers purchase costly project estimation software. Alternatively, managers can use a horde of programmers to create a prototype application to gauge the difficulty of the project. None of these choices are cost or time effective.

However, there is a much more elegant solution to this problem. Code generators can quickly and easily create an application prototype. Have your software architect construct a database according to the project requirements. Point the code generator to your database, and in minutes you will have a complete prototype of your application. It is much easier to estimate a project using a physical, usable example.

Suppose you were put in charge of a project to create a help desk web application. Your company’s business has grown too large, and your fellow co-workers are drowning in technical issues. As the project manager, you have to create an estimation of how long the project will take. You would need to create a system that manages information such as: problem history, priority levels, equipment, support staff, and problem resolutions. This would be a large and difficult undertaking, and you need a way to gauge the level of work necessary to complete it. Using a code generator, you can merely point it to the database created by your software architect based on current version of project requirements, and in minutes, you have a working prototype. You can now figure out exactly how much time and resources you will need to build your help desk.

This allows you to provide near instantaneous feedback to project stakeholders. The stakeholders can view the prototype to validate requirements, and to create new ones. New requirements will call for a revision of your estimate, and you can use the code generator again and again until the definitive requirements have taken shape.

Your development team may decide to completely scrap the generated code and built an application from scratch. It still had helped you in project estimation and saved time and money. Through the use of a code generator, project estimation became a much more efficient and cheaper process.

As an added bonus, some of the code may end up being useful and serve as a foundation, or become a part of the final product.