Working with Rails – Setting up and connecting to a database

The first thing to grasp is that Rails is often referred to as opinionated software (see http://www.oreillynet.com/pub/a/network/2005/08/30/ruby-rails-david-heinemeier-hansson.html. It encapsulates an approach to web application development centered on good practice, emphasizing automation of common tasks and minimization of effort. Rails helps developers make good choices, and even removes the need to make choices where they are just distractions.

In this article, authors Elliot Smith and Rob Nichols explain the setup of a new Rails application and how to integrate it with other data sources.

Working with Microsoft Dynamics AX Forms

Forms in Dynamics AX represent the user interface and are mainly used for entering or modifying data. They are also used for running reports, executing user commands, validating data, and so on.

Normally, forms are created using the AOT by creating a form object and adding form controls such as tabs, tab pages, grids, groups, data fields, images, and others. Form behavior is controlled by its properties or the code in its member methods. The behavior and layout of form controls are also controlled by their properties and the code in their member methods. Although it is very rare, forms can also be created dynamically from the code.

In this aticle by Mindaugas Pociusco-author of Microsoft Dynamics AX 2012 Development Cookbook, we will look at:

• Creating a dialog
• Handling a dialog event
• Building a dynamic form
• Adding a form splitter
• Creating a modal form

Creating a dialog

Dialogs are a way to present users with a simple input form. They are commonly used for small user tasks, such as fi lling in report values, running batch jobs, presenting only the most important fi elds to the user when creating a new record, and so on. Dialogs are normally created from X++ code without storing actual layout in the AOT.

The application class Dialog is used to build dialogs. Other application classes, such as DialogField , DialogGroup , DialogTabPage , and others, are used to create dialog controls. A common way of using dialogs is within the RunBase framework classes, where user input is required.

In this example, we will demonstrate how to build a dialog from the code using the RunBase framework class . The dialog will contain customer table fi elds shown in different groups and tabs for creating a new record. There will be two tab pages, General and Details. The first page will have Customer account and Name input controls. The second page will be divided into two groups, Setup and Payment, with relevant fields inside each group. The actual record will not be created, as it is out of scope of this example. However, for demonstration purposes, the information specifi ed by the user will be displayed in the Infolog.

How to do it...

Carry out the following steps in order to complete this recipe:

1. Open the AOT, and create a new class CustCreate with the following code:

code 1

2. In order to test the dialog, run the class. The following form should appear with the General tab page open initially:



3. Click on the Details tab page to see the following screen:



4. Enter some information into the fi elds and click on OK. The results are displayed in the Infolog:



How it works...

First, we create a new class CustCreate. By extending it from RunBase, we utilize a standard approach of developing data manipulation functions in Dynamics AX. The RunBase class defines a common structure and automatically adds additional controls, such as OK and Cancel buttons to the dialog. Then we declare class member variables, which will be used later. Variables of the DialogField type represent user input fields. Other variables are used to store the actual user input.

The pack() and unpack() methods are normally used to convert an object to a container, which is a format to store an object in the user cache (SysLastValue) or to transfer it between Server and Client tiers. RunBase requires those two methods to be implemented in all its subclasses. In this example, we are not using any of the pack()/unpack() features, but because those methods are mandatory, we return an empty container from pack() and true from unpack().

The layout of the actual dialog is constructed in the dialog() member method. Here, we define local variables for the dialog itself—tab pages and groups. Those variables, as opposed to the dialog fields, do not store any value for further processing.

The super() of the RunBase framework creates the initial dialog object for us. The object is created using the Dialog application class. The class actually uses an AOT form named Dialog as a base, as a base, automatically adds the relevant controls, including OK and Cancel buttons, and presents it to the user as a dialog.

Additional controls are added to the dialog by using the addField(), addGroup(), and addTabPage() methods. There are more methods to add different types of controls, such as addText(), addImage(), addMenuItemButton(), and others. All controls have to be added to the dialog object directly. Adding an input control to groups or tabs is done by calling addField() right after addGroup() or addTabPage(). In the previous example, we added tab pages, groups, and fields in logical sequence top down. Notice that it is enough only to add a second tab page, the first one labeled General is added automatically by the RunBase framework.

Values from the dialog controls are assigned to variables by calling the value() member method of DialogField class. If a dialog is used within the RunBase framework, as in this example, the best place to assign dialog control values to variables is the getFormDialog() member method. RunBase calls this method right after the user clicks OK.

The main processing is done in the run() method. For demonstration purposes, this class only shows the user input the Infolog.

In order to make this class runnable, the static method main() has to be created. Here, we create a new CustCreate object, invoke user dialog by calling the prompt() method, and once the user finishes entering customer details by clicking OK, we call the run() method to process the data.

Handling a dialog event

Sometimes in the user interface, it is required to change the status of one field, depending on the status of another field. For example, if the user marks the Show filter checkbox, then another field, Filter, appears or becomes enabled. In AOT forms, this can be done using input control modified() event. However, if this feature is required on runtime dialogs, handling events are not that straightforward.

Very often, existing dialogs have to be modified to support eventing. The easiest way of doing that is of course to convert a dialog into an AOT form. However, in cases when the existing dialog is complex enough, probably a more cost effective solution would be to implement dialog event handling instead of converting it into an AOT form. Event handling in dialogs is not as flexible as in AOT forms, but in most cases it does the job.

In this recipe, we will create a dialog very similar to the previous one, but instead of entering the customer number, we will be able to select it from the list. Once the customer is selected, the rest of the fields will be completed automatically by the system from the customer record.

How to do it...

Carry out the following steps in order to complete this recipe:

How it works...

The new class CustSelect is actually a copy of the CustCreate class from the previous recipe with a few changes. In its class declaration, we leave all DialogField declarations and remove the rest of the variables.

The methods pack()/unpack() remain the same as we are not using any of their features. In the dialog() member method, we call the allowUpdateOnSelectCtrl() method with the argument true to enable input control event handling. We also disable all controls apart from the Customer account by calling enable() with parameter false for each control. The member method dialogSelectCtrl() of the RunBase class is called every time the user modifies any input control in the dialog. It is the place where we have to add all the required code to ensure that, in our case, all controls are populated with the correct data from the customer record, once the Customer account is chosen.

The static main() method ensures that we can run this class.

There's more

Usage of the dialogSelectCtrl() method sometimes might appear a bit limited as this method is only invoked when the dialog control loses its focus. Also, no other events can be controlled, and it can become messy if events on multiple controls need to be processed.

The Dialog class does not provide direct access to the underlying form's event handling functions, but we can easily access the form object within the dialog. Although we cannot create the usual event handling methods on runtime form controls, we can still control this in a slightly different way. Let us modify the previous example to include more events. We will add an event on the second tab page, which is triggered once the page is activated.

First, we have to override the dialogPostRun() method on the CustSelect class:

code 3

Here, we enable event overloading on the runtime form after it is fully created and is ready for displaying on the screen. We also pass the CustSelect object as an argument to the controlMethodOverloadObject() method to make sure that the form knows where the overloaded events are located.

Next, we have to create a method that will be executed once the tab page is opened:

code 4

The method name consists of the control name and event name joined with an underscore. Now run the class again, and select the Details tab page. The message should be displayed in the Infolog.

Before creating such methods, we first have to get the name of the runtime control. This is because the dialog form is created dynamically, and the system defines control names automatically without allowing the user to choose them. In this example, we have to temporarily add the following code to the bottom of the dialog(), which displays the name of the Details tab page control. Just replace the following code:

code 5

With the following code:

code 6

Running the class would display the name of the control in the Infolog.

Note that this approach may not work properly if the dialog contains an automatically-generated query. In such cases, control names will change if the user adds or removes query ranges.

Working with Microsoft Dynamics AX and .NET: Part 1

This article by Erlend Dalen, explains how you can use .NET classes in AX with the Common Language Runtime and how you can write .NET code that uses AX classes by using the .NET Business Connector for AX.

The topics covered in this article are:

• A brief description of Common Language Runtime (CLR)
• Adding .NET references to classes in AX
• Using a .NET class in X++
• Adding references to the .NET Business Connector
• Using the .NET Business Connector in .NET classes

Working with JSON in PHP jQuery

In this article, by Vijay Joshi, author of PHP jQuery Cookbook, we will cover:

• Creating JSON in PHP
• Reading JSON in PHP
• Catching JSON parsing errors
• Accessing data from a JSON in jQuery

Working with JRockit Runtime Analyzer

In this article series by Marcus Hirt and Marcus Lagergren, authors of Oracle JRockit: The Definitive Guide, you will learn:

• Different ways to create a JRA recording
• How to find the hot spots in your application
• How to interpret memory-related information in JRA

In the sequel—Working with JRockit Runtime Analyzer- A Sequel, we will cover the following:

• How to hunt down latency-related problems
• How to detect indications of a memory leak in an application
• How to use the operative set in the JRA latency analyzer component

Working with JavaScript in Drupal 6: Part 1

In this article by Matt Butcher, we will be working with JavaScript inside of a Drupal environment. We will begin by exploring how JavaScript is included in Drupal pages, and then create our first script for Drupal. While we're not going to cover the basics of the JavaScript language (there are already lots of available resources on the topic), the code we create here will be simple and straightforward.

The purpose of this article is to cover the basics on how JavaScript can be used within Drupal 6. In that regard, this article will serve as a foundation for future JavaScript development. Here are the topics that we're going to cover:

• Serving JavaScript from Drupal
• Creating a first script

Working with Geo-Spatial Data in Python

In this article, we combine the Python libraries and geo-spatial data to accomplish a variety of tasks. These tasks have been chosen to demonstrate various techniques for working with geo-spatial data in your Python programs; while in some cases there are quicker and easier ways to achieve these results (for example, using command-line utilities), we will create these solutions in Python so you can learn how to work with geo-spatial data in your own Python programs.

This article by Erik Westra, author of Python Geospatial Development, will cover:

• Reading and writing geo-spatial data in both vector and raster format
• Changing the datums and projections used by geo-spatial data
• Representing and storing geo-spatial data within your Python programs

Working with Forms in Dynamics AX: Part 2

Read Part One of Working with Forms in Dynamics AX here.

Working with Flexible Content Elements in TYPO3 Templates

Working with Flexible Content Elements introduces one of the most powerful and useful technologies in TemplaVoila, flexible content elements. Flexible content elements allow developers to create new content types utilizing the power of TemplaVoila for specialized purposes such as displaying contact information or product ads consistently across a site. The article explains the main concepts and walks readers through multiple examples.

In this article, by Jeremy Greenawalt, author of TYPO3 Templates, you will:

• Learn about flexible content elements
• Create your first flexible content element to display contact information
• Create an FCE to wrap a group of content elements in a div tag for custom styling
• Use an FCE to create multi-column layouts inside any TemplaVoila content area
• Create a flexible content element for product displays