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

TFS interaction with models and layers

An element, such as a table, is stored down at the field level. Changes to a field will only place that field in the current layer. This also means that the same table can have two different fields in different models in the same layer. When we export a model, it will only export the changes within that model; any fields that are in the model will not be exported. This is by design, and has many benefits when deploying a release or applying a hotfix.

TFS integration is file-based and works by AX, exporting an XPO of each element to the local repository when the element is saved. The link between the file and AX is held at the element level, as shown in the following example from our local development environment:

\Data Dictionary\Tables\ConFMSVehicleGroup maps to C:\Projects\VCS\AX\6015GettingStarted\ConFleetManagement\Data Dictionary\Tables\ ConFMSVehicleGroup.xpo.

Even though the resulting XPO will only contain the changes, it means the changes in the layer, not the specific model.

To demonstrate what happens with version control when we add a field to an element in a different model, follow these steps:

  1. Check out the ConFMSVehicleGroup table.

  2. Add a new field to this table by dragging the CustAccount EDT onto its Fields node.

  3. Save the table and ensure that the new field's model is USR Model.

  4. Check in the table.

Open the XPO for the table under the ConFleetManagement model's folder structure, and you'll see that the new field will be there. The folder structure for USR Model will not contain the element at all.

This means that an element must only be in one model—we must not have fields, methods, or controls in different models in the same layer. This is good practice and should not be considered as a limitation.

In terms of layers, there is a technical limitation where elements under source control must not also be modified in a higher layer. For example, if we are working in the VAR layer, the same object must not also be in the USR layer. This shouldn't pose a practical problem in normal deployment procedures.

For example, where the VAR has vertical solutions or add-ons, they should be brought in at the lowest layer possible (ISV or VAR), and the modifications made under source control should be made in the layer above that, such as the VAR or CUS layer.

If the customer also has an internal development team working on a separate functionality set in a separate layer, such as the USR, their environment will be built from the partner or ISV supplier models, and when ready for deployment, they will move their model to the build server.

Previous Section
End of Section
Next Section