Book Image

Mastering Microsoft Dynamics AX 2012 R3 Programming

By : Simon Buxton, Mat Fergusson
Book Image

Mastering Microsoft Dynamics AX 2012 R3 Programming

By: Simon Buxton, Mat Fergusson

Overview of this book

<p>Due to its interesting capabilities such as finance and supply chain management, business intelligence and reporting, project management, and so on, Microsoft Dynamics is one of the most widely used solutions adopted by many organizations across the globe. This book is a step-by-step tutorial that covers elements from the initial design through to development. Each concept is fully explained and demonstrated by the creation of a real-world project. You will learn some really useful, advanced development techniques such as extending your code with metadata and exception handling.</p> <p>This book is an invaluable tutorial if you are moving from another ERP system or language, or if you are a technical consultant with a desire to create efficient functional designs and business solutions.</p>

Related Content you might be interested in

Current Title:

Small book image
Mastering Microsoft Dynamics AX 2012 R3 Programming
Simon Buxton | Mat Fergusson
Jun, 2015 | 478 pages
No titles found
Table of Contents (21 chapters)
Mastering Microsoft Dynamics AX 2012 R3 Programming
Mastering Microsoft Dynamics AX 2012 R3 Programming
Credits
Credits
About the Authors
About the Authors
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Preparing Our Solution
Preparing Our Solution
The technical architecture of a solution
Minimizing the footprint of changes
Selecting the appropriate layer for our solution
Configuring source control
Creating the models
Creating a label file
Creating a project
Setting up the default project and model
Designing the technical solution
Designing test plans
Summary
2
Creating Data Structures
Creating Data Structures
Designing the data structures for our solution
Creating labels
Creating the setup tables
Creating enumerated types
Creating the vehicle table
Creating the vehicle service data table
Referential integrity – delete actions and validation
Summary
3
Creating the User Interface
Creating the User Interface
Creating a menu structure
Understanding the patterns used in interface design
Creating setup forms
Creating the vehicle list page
Investigating form events
Taking more control over the form layout
Creating the vehicle create form with the handler class
Summary
4
Creating Business Logic and Hooking into Core AX
Creating Business Logic and Hooking into Core AX
Moving table validation and logic into a class
Adding navigation
Number sequences
Hooking into standard AX logic using event handling
Summary
5
Adding Business Intelligence
Adding Business Intelligence
What are parts?
Creating info parts to show key business data
Creating a form part
Creating cues and cue groups
Using form parts on a form
Summary
6
Extending the Solution
Extending the Solution
Adding secondary list pages
Using menu items to change the vehicle status
Adding a drop dialog to change vehicle group
Exposing the vehicle group logic as a custom web service
Summary
7
Designing Your Security Model
Designing Your Security Model
Setting up license and configuration keys
Designing the security structure
Creating privileges
Creating duties
Creating roles
Providing access to server methods – code permissions
Designing and creating process cycles
Restricting access to data using policies
Summary
8
Customizing Standard AX
Customizing Standard AX
Key goals when customizing standard or third-party code
How to determine where to make the change
Adding fields to tables
Integrating a custom module with standard AX
Using an extension table for additional fields
Changing the behavior of a class
Extending a framework – vendor electronic payments
Summary
9
Advanced Features and Frameworks
Advanced Features and Frameworks
Adding custom filters to list pages
Advanced methods of adding ranges to list pages
Using the SysOperation framework
Using the SysOperation framework execution modes
Customizing the user interface displayed by the SysOperation framework
Tracking progress of scheduled tasks
Understanding the global address book
Accessing the financial dimension framework
Summary
10
Advanced Development Techniques
Advanced Development Techniques
Making data date-effective
Utilizing metadata within AX
Making your code extendable with metadata
Exception handling
Controlling how and where code is executed
Code access permissions
More on views – computed columns
Summary
11
Unit and Performance Testing
Unit and Performance Testing
Unit testing
Using the debugger
Automated unit testing
Creating unit tests with data isolation
Reviewing the results of the unit test
Code and database performance testing through code profiling
Summary
Efficient Design and Development with Microsoft Dynamics AX
Efficient Design and Development with Microsoft Dynamics AX
The technical overview of Dynamics AX
Layers and models
The MorphX IDE
The options for source control
General development practices
Patterns and frameworks
Using Version Control
Using Version Control
When to add to version control
Working with version control
TFS interaction with models and layers
Designing a deployment procedure
Building the solution
Label files
Code Editor Scripts
Code Editor Scripts
Editor scripts
Code snippet – code commenting
Code snippet – the find method
Index
Index

Building the solution

There are many scripts to help us build the solution, which can be very complicated. To get us started, the following scenario can work well for many implementations.

In this scenario, we have several developers working on a solution for the VAR, and a team of two working on security and reports in the USR layer.

The customer's environment consists of the following:

  • A shared development server or a VM for each developer

  • A build sever

  • A test server

  • The production or live server farm

The VAR's environment will consist of these:

  • A virtual machine for each developer (and also per customer they are working)

  • A build server, which also acts as a unit test machine

The process starts at the VAR when all developers have checked in the code-complete unit tested code. The following steps cover the general process:

  1. The build server at the VAR will be rebuilt from an AX 2012 VM template of the correct service pack level.

  2. It will then be configured to link to the TFS repository.

  3. The developer will then navigate to Version Control | Synchronise, check Force in the dialog, and press OK.

  4. This will be repeated for each model.

The models will then be exported and delivered to the customer's site. At the customer's site, the following steps are performed:

  1. The customer's build server will be refreshed from live (using database backup and restore for at least the model store database, and the business database too if policies allow).

  2. The models will be installed from the VAR.

  3. If using version control, one developer will synchronize his/her virtual machine with source control.

  4. The models will be exported from the developer's VM or the shared development environment.

  5. The models are then imported into the build server and then fully compiled.

  6. The test server will be refreshed from live using database backup and restore of both the databases (the baseline is not relevant for this).

The model store can now be moved to test in its entirety. This is because the build server was refreshed from live, and therefore, the element IDs will match the live server. Importing models will only create element IDs if they don't already exist. Once we have performed our user acceptance test in test, it can then be deployed in live.

This is a simplistic method, which avoids the use of build scripts. Build scripts may seem complicated, but once they are set up, the whole process can be automated. The following material is useful for more detail on the best practices with source control as well as for creating your own automated build process:

Previous Section
End of Section
Next Section