Home Page Icon
Home Page
Table of Contents for
Cover
Close
Cover
by Mat Fergusson, Simon Buxton
Mastering Microsoft Dynamics AX 2012 R3 Programming
Mastering Microsoft Dynamics AX 2012 R3 Programming
Table of Contents
Mastering Microsoft Dynamics AX 2012 R3 Programming
Credits
About the Authors
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers, and more
Why subscribe?
Free access for Packt account holders
Instant updates on new Packt books
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example code
Downloading the color images of this book
Errata
Piracy
Questions
1. Preparing Our Solution
The technical architecture of a solution
Data structures
The user interface
Application logic
Minimizing the footprint of changes
Where to make the change
The use of field groups
Eventing
Event subscription
Delegates
Extending a class
Table-level form events
Selecting the appropriate layer for our solution
Configuring source control
Configuring AX to use MorphX VCS
Configuring AX to use Team Foundation Services
Using Visual Studio Online with AX CU7 or prior
Creating a new TFS project using Visual Studio Online
Configuring AX version control parameters to connect to TFS
Troubleshooting
Creating the models
ISV models
VAR models
Customer or end user models
Creating the models
Creating a label file
Creating a project
Setting up the default project and model
Designing the technical solution
Data structure design considerations
Extended data types
Base enums – enumerated types
Tables
Views
Maps
Classes
Forms
Designing test plans
Summary
2. Creating Data Structures
Designing the data structures for our solution
Creating labels
Creating the setup tables
Creating the vehicle group table
Creating extended data types
Creating the table
Adding fields to the table
Creating field groups
Creating indexes
Adding the find and exist methods
Completing the primary key EDT
More on indexes
Creating the vehicle service schedule table
Creating enumerated types
Creating the vehicle table
Creating the enumerated types for the vehicle table
Creating the table that supports inheritance
Completing the table relations
Completing the vehicle table
Creating the inherited tables
More on the InstanceRelationType property
Creating the vehicle service data table
Referential integrity – delete actions and validation
How this works
Summary
3. Creating the User Interface
Creating a menu structure
Customizing an existing menu
Understanding the patterns used in interface design
Form structure
Creating setup forms
The vehicle group form
Creating the menu item
The vehicle service data form
Creating the vehicle list page
Creating the Details form
Creating the list page interaction class
Creating the base query for the list page
Creating the 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
Moving table validation and logic into a class
Implementing the pattern
Adding validation logic
Adding business logic
Checking whether the record has a service schedule
Getting the service schedule record
Creating the NextServiceDate and NextServiceOdo methods
Testing
Adding navigation
Adding the ability to create a service record for a vehicle
Initializing the service record from the vehicle record
Creating the initFrom method
Modifying the form handler to store a vehicle record
Modifying the service details form to detect whether it was called with a vehicle
Modifying the form handler to initialize from the vehicle
Viewing vehicle service records for a vehicle
Number sequences
Defining a number sequence
Configuring the table to automatically apply the number sequence
Hooking into standard AX logic using event handling
Associating the appointment with a vehicle
Adding custom fields to the appointment table
Creating a class to handle the modifiedField event
Creating the event handler method
Adding a subscription to TMSAppointmentTable.modifiedField
What happens when the code executes
Creating a delegate for use by other parties
Summary
5. Adding Business Intelligence
What are parts?
Creating info parts to show key business data
Creating a query for the part
Creating the info part
Creating the part's menu item
Adding the info part to the All loads list page
Completing the info part
Creating a form part
Creating the form for the form part
Creating the form part reference
Creating the menu item and associating it with the vehicle table
Creating cues and cue groups
Creating the service history cue
Creating a Preview part for the cue
Creating an appointment cue
Using form parts on a form
Creating a view to aggregate the data for the form part
Creating a query for the view
Creating the view using the query as a data source
Creating the query for the form part
Creating the form for our form part
More on queries and forms
Creating links between forms programmatically
Summary
6. Extending the Solution
Adding secondary list pages
Adding a list page for active vehicles
Adding a list page for inactive vehicles
Using menu items to change the vehicle status
Creating the data contract class
Creating the class to process the update
Database transactions
Adding further validation to the status change
Hooking up the code with the interface
Creating the menu item handler class
Creating the menu items
Adding the menu items to the list page
Adding a drop dialog to change vehicle group
Creating a drop dialog form
Exposing the vehicle group logic as a custom web service
Creating the service class and service
Creating the Visual Studio test project
Creating a service method to change the vehicle group
Getting information from the infoLog object
Creating the updateVehicleGroup service method
Updating the Visual Studio service test project
Creating a service method to return a list of vehicle groups
Creating a utility method to convert an AifQueryCriteria object to a Query object
Creating a vehicle group data contract
Creating the service method
Using the new service within the Visual Studio test project
Summary
7. Designing Your Security Model
Setting up license and configuration keys
Legacy security features
Designing the security structure
Impact on licensing
Designing the security structure
Creating privileges
How privileges affect security and user experience
Hiding buttons that the user has no access to
Refining access to the data
Providing access to services
Server methods
Creating duties
Creating roles
Testing the security roles
The relationship between client security tools and the AOT
Providing access to server methods – code permissions
Code access permissions for a privilege
Creating a code permission
Designing and creating process cycles
Restricting access to data using policies
Summary
8. Customizing Standard AX
Key goals when customizing standard or third-party code
How to determine where to make the change
Cross-reference data
Cross reference – Used by
Keeping the cross-reference data up to date
Cross reference – Using
Type hierarchy
Adding fields to tables
Field groups
Integrating a custom module with standard AX
Adding the vendor ID reference to the vehicle table
Marking a vendor as a vehicle service provider
Reference group controls
Creating a custom lookup for reference group controls
Creating a custom lookup for standard fields
Adding a method to state whether this is a vehicle service provider or not
Using event handlers to reduce footprint on 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
Adding custom filters to list pages
Advanced methods of adding ranges to list pages
Using the SysOperation framework
Using the SysOperation framework execution modes
Executing code asynchronously
Executing code using the batch framework
Last value and usage data
Handling the result of a task processed asynchronously
References
Customizing the user interface displayed by the SysOperation framework
Tracking progress of scheduled tasks
Understanding the global address book
Electronic addresses
Postal addresses
Creating addresses programmatically
Accessing the financial dimension framework
References
Summary
10. Advanced Development Techniques
Making data date-effective
Utilizing metadata within AX
Accessing the data model using metadata
Accessing code using metadata
Making your code extendable with metadata
Interfaces
Sample solution using metadata
The design
Creating a utility class
Creating the interface class
Creating the user interface
Creating the form control definition contract class
Creating the form builder class
Updating the vehicle table form
Taking this further
Exception handling
Handling general exceptions
Handling CLR exceptions
Handling table update exceptions
Controlling how and where code is executed
Constructing code on a specific tier
Passing data between client and server
Serializing classes using the SysPackable interface
Executing code in CIL
Code access permissions
File I/O permission
The CLR interop permission
More on views – computed columns
How SQL Server executes views
Adding a computed column
A note on performance of computed columns
Creating a computed column – concatenating two fields
Creating a computed column – return data from related tables
Other useful functions
Common misconceptions
Summary
11. Unit and Performance Testing
Unit testing
Code review
Test-driven development
Using the debugger
Automated unit testing
Creating automated unit test cases
Creating the unit test project
Creating a unit test case
Running the unit test case
Creating unit tests with data isolation
Setup and teardown of test data
Reviewing the results of the unit test
Code and database performance testing through code profiling
Interpreting the results
Enabling SQL execution plans
Investigating the performance of views
References
Summary
A. Efficient Design and Development with Microsoft Dynamics AX
The technical overview of Dynamics AX
The model store database
The compiler and CIL
Layers and models
Layers
Models
The MorphX IDE
AOT
Saving your work
The Projects window
The options for source control
General development practices
Naming
Commenting
Editor scripts
Patterns and frameworks
Patterns
Frameworks
B. Using Version Control
When to add to version control
Working with version control
Adding a model to version control
Managing AOT elements with version control
Version control options
Changes
Pending Objects
Synchronise
Synchronisation log
TFS interaction with models and layers
Designing a deployment procedure
Building the solution
Label files
C. Code Editor Scripts
Editor scripts
Code snippet – code commenting
Code snippet – the find method
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Next
Next Chapter
Table of Contents
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset