Piyush's D365 F&O Tech Blog

From LCS to PPAC: Microsoft D365 F&O Power Platform Admin Center (PPAC) for new D365 F&O Implementations by 2026

2026-08-31T07:06:33.365-07:00

For years, Lifecycle Services (LCS) has been the home base for Dynamics 365 Finance & Operations, but Microsoft is modernizing the administration and lifecycle management experience. Microsoft is moving key support and administration capabilities into the Power Platform Admin Center (PPAC). A key part of this evolution is the transition from Lifecycle Services (LCS) to the Power Platform Admin Center (PPAC) as the primary operational and administrative hub. This shift is more than a UI change; it is a step toward a unified admin experience across Dynamics 365, Power Apps, and the wider Power Platform.

One Dynamics One Platform: Microsoft's Vision

The move toward One Dynamics One Platform is the foundation behind Microsoft’s transition strategy.

Rather than treating Dynamics 365 as a standalone ERP ecosystem, Microsoft is gradually aligning Dynamics applications with the same governance and operational framework used across the Power Platform.

This creates a more connected administration model where:

Environment governance becomes centralized
Security controls operate consistently across services
Administrative experiences become standardized
Release operations align across platforms
AI, automation, and analytics services integrate more naturally with Dynamics 365 workloads

The objective is not simply consolidation. It is operational consistency.

Under this model, Dynamics 365 environments are expected to function as part of a broader business application ecosystem rather than isolated ERP implementations. This also supports Microsoft’s larger SaaS direction, where platform services, AI capabilities, automation, and business applications increasingly operate within a shared operational layer.

This is also where Microsoft’s Unified Developer Experience begins to play a larger role. Development, deployment, administration, and Dataverse integration are gradually being aligned within a single operational framework managed through PPAC rather than separate LCS-driven environments.

Why is Microsoft Moving from LCS to PPAC?

The decision to migrate from Lifecycle Services (LCS) to Power Platform Administration Center (PPAC) is not arbitrary housekeeping. Microsoft has spent several years collapsing separate product estates into one platform, and Finance and Operations was the last major workload standing outside it.

The reasoning is coherent, and it matters because it tells you which direction future investment flows. Here are 5 key reasons that Microsoft is migrating from LCS to PPAC:

One administrative surface. Environments, capacity, security and governance for ERP now sit alongside Power Apps and Dataverse instead of in a portal only ERP administrators ever opened.
Native Dataverse architecture. Finance and Operations runs as an application inside a unified environment rather than as an isolated deployment with a bolted-on integration.
Modern lifecycle management. Deployment moves toward the same solution and pipeline patterns already used across the Dynamics 365 stack.
New capability lands in PPAC first. Monitoring, governance controls, analytics and Copilot features are being built for the unified platform. Staying on LCS increasingly means opting out of the roadmap.
Capacity governed centrally. Storage and compute are measured and enforced at tenant level, which is precisely why this transition has a cost dimension most organizations have not modeled.

LCS vs PPAC Migration: What Changes for Dynamics 365 F&O

One of the biggest operational shifts involves environment provisioning and development workflows. Under the Unified Developer Experience approach, developers work through locally installed Visual Studio environments connected directly to cloud-hosted development environments managed through PPAC.

This changes the traditional dependency on cloud-hosted development VMs and VHD-based setups that were commonly used in LCS-driven environments.

The move also strengthens Microsoft’s push toward standardized SaaS operations, where environment management, governance, and development workflows align more closely with broader Power Platform administration practices.

How Dynamics 365 Release Management Is Evolving

One of the most significant operational impacts of the move from LCS to PPAC involves Dynamics 365 release management.

Many organizations built their deployment and servicing processes directly around Lifecycle Services. Release coordination, update scheduling, deployment orchestration, and environment servicing were all tightly connected to LCS workflows.

Under the newer PPAC and Unified Developer Experience model, Microsoft is moving toward stricter CI/CD-driven deployment practices.

This introduces several changes to how releases are managed across Dynamics 365 environments:

Development happens through local Visual Studio environments connected to cloud-hosted development environments
Deployments to the sandbox and production environments are expected to move through Azure DevOps pipelines
Unified deployment packages become part of the standardized deployment process
Manual deployment flexibility is reduced in favor of controlled release orchestration
Governance and approval workflows become more centralized through PPAC

The shift becomes more visible when comparing how release operations were traditionally handled in LCS environments versus the newer PPAC-aligned model.

What Changes for Admin Roles and Partner Access?

Under Lifecycle Services, users from any tenant could be added to a project and immediately work on a customer’s behalf. That model is gone. In PPAC, persistent support access requires a genuine admin role, Service Support Administrator or Helpdesk Administrator, and partners must operate through delegated administration to be linked correctly to the customer tenant.

A temporary Lifecycle Services User role softens the transition when users arrive via an LCS link, but Microsoft has stated it will be removed once the transition completes. There is a governance trap here worth naming out loud. Helpdesk Administrator also permits resetting passwords for non-admin users.

Organizations that hand out that role simply so a functional consultant can file a support ticket are granting materially broader privileges than they intend. Decide deliberately who holds these roles before someone grants them under pressure during an incident.

How Does the LCS to PPAC Migration Benefit Your Long-Term Roadmap?

Framed correctly, this is not a retreat from something failing. It is the opportunity to rebuild your ERP operating model on the platform Microsoft is actually investing in, with governance, capacity discipline, and development practice that will hold through the next several waves of change.

Here are 5 keyways the LCS to PPAC migration will benefit your long-term business strategy:

You inherit the investment path. New monitoring, governance, analytics and AI capability is being built for the unified platform first.
Your development practice modernizes. Fully functional developer environments and solution-based deployment replace VM maintenance and package uploads.
Governance becomes tenant wide. Environment policies, DLP and access control apply consistently across ERP and the wider platform instead of stopping at the ERP boundary.
Capacity becomes visible and therefore manageable. You cannot govern what you cannot see, and tenant-level reporting finally makes storage a managed line rather than a surprise.
Analytics and Fabric alignment. Dataverse-native ERP integrates with modern analytics architecture rather than requiring a bridge to it.
You build organizational muscle memory early. Teams that migrate deliberately arrive at the mandatory phase experienced. Teams that wait arrive at it learning.

Manually Restore an MSSQL Database in SQL Management Studio

2014-07-04T03:05:00.000-07:00

Hi Everyone,

If you need to manually restore an SQL Database in Management Studio you can follow the instructions below for the version of SQL Server running on your server.

SQL 2012:

Log onto SQL Server Management Studio.
Navigate to the database you wish to restore.
Right Click > Tasks > Restore > Database.
Once on the General tab set the source to Device > Select Backup Device > Add > Navigate to the .bak file you're restoring to.
Ensure The Destination Database is the correct one.
Select the Options tab.
Check "Overwrite the existing database (WITH REPLACE)" and "Close existing connections to destination database".
Uncheck "Take tail-log backup before restore".
Click OK.

Why we uncheck the Take tail-log Backup Before restore??

Tail-log backups are new to SQL Server 2005. The tail-log backup captures records on the transaction log that were written since the last transaction log backup. If you’re going to restore a database to the point of failure, then you need to take a tail-log backup before you start the restore operation.

If you’re going to restore to a point in time prior to the last transaction log backup, if you’re moving the database from one server instance to another, or if you’re overwriting the existing database, then you won’t need a tail-log backup. If the transaction log is damaged and you can’t take a tail-log backup, then you must restore without one.

SQL 2008:

Log into SQL Server Management Studio.
Navigate to the database you wish to restore.
Right click > Tasks > Restore > Database.
Once on the General tab select "From Device" for the source for restore, then navigate to the .bak file you're restoring to.
Ensure the Destination for restore is set to the correct database.
Select the Options tab.
Check "Overwrite the existing database (WITH REPLACE)"
Click OK

How To Find a User's Security Identifier (SID) in Windows

2013-11-29T00:16:00.000-08:00

Hi to All,

It'll take less than a minute to find a user's SID in Windows.

Here's How:

Open Command Prompt.
Once Command Prompt is open, type the following command exactly as shown here, including spaces or lack thereof:
```
wmic useraccount get name,sid
```
```
and then press Enter. 
```
You should see a table, similar to the following, displayed in the Command Prompt window:
```
Name            SID
Administrator   S-1-5-21-1180699209-877415012-3182924384-581
Guest           S-1-5-21-1180699209-877415012-3182924384-604
Bob             S-1-5-21-1180699209-877415012-3182924384-1342
Test            S-1-5-21-1180699209-877415012-3182924384-1974
Piyush          S-1-5-21-1180699209-877415012-3182924384-10347
```
```
This is a list of each user account in Windows, listed by user name, followed by the account's corresponding SID.
```
1. How To Find User's SIDs in the Registry:
  
  You can also determine a user's SID by looking through the ProfileImagePath values in each S-1-5-21 prefixed SID listed under theHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList key.
  
  The ProfileImagePath value within each SID-named registry key lists the profile directory, which includes the user name.
  
  For example, the ProfileImagePath value under the S-1-5-21-1180699209-877415012-3182924384-1004 key on my computer is C:\Users\test so I know that the SID for the user "Tim" is "S-1-5-21-1180699209-877415012-3182924384-1974".
  
  Note: This method of matching users to SIDs will only show those users who are logged in or have logged in and switched users. To continue to use the registry method for determining other user's SIDs, you'll need to log in as each user on the system and repeat these steps. This is a big drawback so, assuming you're able, you're much better off using the wmic command method above.
```
 
```
```
  
```

Creation of Item or Product and Product master in Dynamics AX 2012

2013-08-28T02:04:00.000-07:00

Here we are going to discuss how to create a product and Product master(Items).

In 2012, ‘Item’ is replaced with ‘Product’. One cannot find an item master in Inventory Management Module, there is a separate module for item/product creation. The Name of that module is ‘Product Information Management’.

There are two types of Products in 2012. They are

1. Product

2. Product Master

1. Product:

These are clearly identifiable products that do not have variations associated with them. You can think of them as standard or base products. Use the Products list page in the Product information management module to view and manage products.

2. Product Master:

These serve as templates or models for variants. The variants of a product master can be either predefined or created in sales scenarios by using a product configurator. A product master is associated with one or more product dimensions, or for some configurators, product attributes. Use the Product master’s list page in the Product information management module to view and manage product masters

To access Product and Product Masters go to Product Information Management a Common Forms a Products a Products /Products Masters.

Product Creation Process:

To create product go to Product Information Management à Common Forms à Products à Products.
Click on New Button, a new product form is opened. In that form select the product type as Item/Service.
- Item- A Tangible item which has inventory transactions and On-hand inventory.
- Service- an Intangible item which has no On-hand inventory.
- Now select Product sub-type, (note- if you open new product form from ‘all products and product master’ then you will be displayed with two option product/product masters in this drop down menu)
- Enter Product Number.
- Press ok and the current form closes and a new line is created in the products list page.

Product/Product Master Creation Process:

To create product go to Product Information Management à Common Forms à Products à Products.
Click on New Button, a new product form is opened. In that form select the product type as Item/Service.
- Item- A Tangible item which has inventory transactions and On-hand inventory.
- Service- an Intangible item which has no On-hand inventory.
- Now select Product sub-type, (note- if you open new product form from all products and product master then you will be displayed with two option product/product masters in this drop down menu)
- Enter Product Number and all the related fields.
- In the product variants section, select product dimensions group and configuration technology.
- Press ok and the current form closes and a new line is created in the products list page.

Assigning Dimensions Groups to a Product Master:

In the product list page, double click on the product.
In the product details form opened, on the top of the form you will find Dimension Group Button.
Click on Dimensions group Button will open a drop down menu.
In the drop down menu you find three fields
- Product Dimension group
- Storage Dimension group
- Tracking Dimension group
- Select the appropriate groups from these menus.

Note:

Please don’t get confused between a ‘Product’ and ‘Product Master’; they are two different product types in AX 2012.

We can assign Product ‘Dimension Group’ to ‘Product Master’ but we can’t assign ‘Dimension Group’ to ‘Product’. ‘Product’ is a unique item which doesn’t have any variants.

Creating Product Dimensions and creating dimension combinations:

In the product details form, in the product master field press product dimensions button.
In the Product dimensions form in the left pane, all the dimensions related to that product will be displayed.
Click on one dimension, the right pane will display the dimension already entered if any.
If you are entering dimensions for the first time, the right pane will be empty.
Now press new button, a new blank line is created. Enter the dimensions.
For example, if you select configuration in the left pane then enter the configuration dimension of the product in the right pane.
Similarly repeat the steps for all the product dimensions.

Product dimension combinations (Product Variants):

Once you create all the dimensions for a product, in ax 2009 we need to create item combinations.
Similarly in ax2012 we use Product Variants.
You can find product variants button in the product master section of the product master details form.
Please refer to the below screenshot

In the product variants form, you can create product dimension combinations using two methods,
- By directly clicking on new button and selecting appropriate configurations. (OR)
- By clicking on ‘Variant Suggestions’ will open a new form displaying all the possible combinations. Just check the select checkbox on the combinations you want and press OK.

Release product to legal entities:

Once you have created the product you need to release that product for use by your companies.
To release a product, go to that product in the product master form and on the top of the form in Product Authorization section press on ‘Release Product for Legal Entities’ button.
Release Products form is opened. Please see the screenshot for your reference.

In the left hand side of the form, press ‘select products’. In the right hand side, all the products will be displayed. Further right to that, you will find all the product variants.
Select the required products or product variants.
Now Press ‘Select Companies’ from left hand side pane. All the companies in the ax will be displayed.
Now select the companies in which you want to use this product and after finishing press OK.
Now you have Released your Product for further use.

Assigning Item Model Group & Item Groups to a Product Master:

In the Released products form (go to product information management module a common forms a Released Products) select your product and click on ‘Edit’ button on top left.

In the Released product details form, in the General Fast Tab , you will find ‘Item Model Group’ Field
From the drop down menu, select an item model group.
In the same form , in ‘Manage costs’ tab posting, field you will find ‘Item Groups’ Field.
From the drop down menu select an Item Group.
Now the item or Product or Product master is ready for further transactions.

Release products to the legal entities using X++ [Dynamics AX 2012]

2013-08-23T00:28:00.000-07:00

In Microsoft Dynamics AX 2012, Microsoft has enhanced the item-product data management framework to provide flexibility and sustainability across the organization.In Microsoft Dynamics AX 2012, all product master data is shared across all companies, and the virtual table collection concept is no longer available for product master data management. The old item representation (InventTable) still exists[msdn]

I will be using 2 legal entities – CEU and newly created legal entity ‘CEE’
[If you want to create new legal entity - Organization administration >> setup >> Organization >> Legal entities >> New]

Let me show you the product master data [a particular product] which I am trying to release using code.

EcoResProductReleaseManagerBase class will help to release products to the legal entities. static method -releaseproduct will release products.

static void SST_ReleaseProducts(Args _args)
{
EcoResProduct ecoResProduct;
;

select firstOnly ecoResProduct where EcoResProduct.DisplayProductNumber == “1100″;
EcoResProductReleaseManagerBase::releaseProduct(ecoResProduct.RecId,
CompanyInfo::findDataArea(‘CEE’).RecId);
}

After running the above job, you will see that 1100 product number has been released to legal entity ‘CEE’ as shown below.

static void SST_ReleaseProducts_detailed(Args _args)

{

EcoResProduct ecoResProduct;
InventTable inventTable;
InventTableModule inventTableModule;
NumberSequenceTable numberSequenceTable;
ItemId itemId;
InventItemSetupSupplyType inventItemSetupSupplyType;

EcoResStorageDimensionGroupProduct ecoResStorageDimensionGroupProduct;
EcoResTrackingDimensionGroupProduct ecoResTrackingDimensionGroupProduct;
EcoResStorageDimensionGroupItem ecoResStorageDimensionGroupItem;
EcoResTrackingDimensionGroupItem ecoResTrackingDimensionGroupItem;
;

select firstOnly ecoResProduct where EcoResProduct.DisplayProductNumber == “1100″; /

changecompany (‘CEE’)
{
ttsBegin;
inventTable = null;
inventTableModule = null;
inventItemSetupSupplyType = null;
ecoResStorageDimensionGroupProduct = null;
ecoResTrackingDimensionGroupProduct = null;
ecoResStorageDimensionGroupItem = null;
ecoResTrackingDimensionGroupItem = null;

numberSequenceTable = InventParameters::numRefItemId().numberSequenceTable();
//get item id from:
//1. Product number if number seq for item ID is not set up or manual or return blank value
if (!numberSequenceTable.RecId || numberSequenceTable.Manual)
{
itemId = ecoResProduct.productNumber();
}
else //number sequence auto, get a number
{
itemId = NumberSeq::newGetNumFromId(numberSequenceTable.RecId).num();
}

inventTable.initValue();
inventTable.initFromEcoResProduct(ecoResProduct);
inventTable.ItemId = ItemId;
inventTable.NameAlias = ecoResProduct.SearchName;
inventTable.insert(true);

// Create inventTableModules

inventTableModule.initValue();
inventTableModule.ItemId = inventTable.ItemId;
inventTableModule.ModuleType = ModuleInventPurchSales::Invent;
inventTableModule.insert();

inventTableModule.initValue();
inventTableModule.ItemId = inventTable.ItemId;
inventTableModule.ModuleType = ModuleInventPurchSales::Purch;
inventTableModule.insert();

inventTableModule.initValue();
inventTableModule.ItemId = inventTable.ItemId;
inventTableModule.ModuleType = ModuleInventPurchSales::Sales;
inventTableModule.insert();

//Create inventItemLocation
InventItemLocation::createDefault(inventTable.ItemId);

// Creates a new item default order type for the product that is released.

inventItemSetupSupplyType.initValue();
inventItemSetupSupplyType.ItemId = inventTable.ItemId;
inventItemSetupSupplyType.ItemDataAreaId = inventTable.DataAreaId;
inventItemSetupSupplyType.insert();

//create relationship tables to dimension groups.

ecoResStorageDimensionGroupProduct = EcoResStorageDimensionGroupProduct::findByProduct(ecoResProduct.RecId);
ecoResTrackingDimensionGroupProduct = EcoResTrackingDimensionGroupProduct::findByProduct(ecoResProduct.RecId);

if (ecoResStorageDimensionGroupProduct.RecId)
{ // mandatory storage dimension group for the product
ecoResStorageDimensionGroupItem.ItemDataAreaId = inventTable.DataAreaId;
ecoResStorageDimensionGroupItem.ItemId = inventTable.ItemId;
ecoResStorageDimensionGroupItem.StorageDimensionGroup = ecoResStorageDimensionGroupProduct.StorageDimensionGroup;
ecoResStorageDimensionGroupItem.insert();
}

if (ecoResTrackingDimensionGroupProduct.RecId)
{ // mandatory tracking dimension group for the product
ecoResTrackingDimensionGroupItem.ItemDataAreaId = inventTable.DataAreaId;
ecoResTrackingDimensionGroupItem.ItemId = inventTable.ItemId;
ecoResTrackingDimensionGroupItem.TrackingDimensionGroup = ecoResTrackingDimensionGroupProduct.TrackingDimensionGroup;
ecoResTrackingDimensionGroupItem.insert();
}
ttsCommit;
info(strfmt(“Product successfully released to ‘CEE’ legal entity”));
}
}

In Microsoft Dynamics AX 2012 inventory dimensions have been divided into the following three categories:
Product dimensions:These correspond to the old item dimensions.
Storage dimensions:These are Site, Warehouse, Location, and Pallet.
Tracking dimensions:These are Batch number and Serial number.

2013-08-23T00:06:00.003-07:00

Hi,

In this post, I would like to share some Product information in Ax 2012 that will help to understand

Inventory structure. In AX 2012 Inventory structure has been completely changed. So in brief

we can understand the same as:

Understanding the Product structure:

Product type
Item type - This option will be selected if the product is an inventoried product

Service type - This option will be selected if the product is a non-inventoried product

Product sub type

Product master - Products of this sub-type must have a product dimension group that
specifies the product dimensions that are active for the product (color, size, and configuration)

o Configuration technology

§ Predefined variant - This type should be chosen if the product will not be

configured, but simply rely on the user’s choice of Color, and/or Size, and/or

Configuration for each transaction

§ Dimension-based configuration - This type should be chosen if the user will

build a configurable BOM that relies on configuration rules to build the

Config ID and the BOM lines. (This technology may only be chosen if

Configuration is active on the Product dimension group selected for the

product)

§ Rule-based configuration - This type should be chosen if the product will

use Product builder

§ Constraint-based configuration - This type should be chosen if the product

will use the new AX 2009 Constraint based product configuration method.

(This technology may only be chosen if Configuration is active and is the lone

Product dimension active for the Product dimension group selected for the

product)

Product - Products of this sub-type do NOT have any product dimensions, and therefore do
not have a product dimension group
Product variant - A large amount of information may be maintained at the Product master

level, including, but not limited to:

o Product dimensions

o Images

o Product categories

o Product attributes

o Unit conversions
For Product master products, Product dimensions and Product variants are

extremely important. Both may be managed from menu items in the ribbons

section of the Products form:

Dimensions

Product dimensions: Color, Size, Configuration
Storage dimensions: Site, Warehouse, Location, Pallet ID
Tracking dimensions: Batch number, Serial number

Release product

Once product variants have been created at the instance level, they must be released

to individual companies before transactions may be performed in the respective

company. Variants may be released from any of the Products forms (All, Distinct,

Product masters), or from the Product variants form by clicking Release products in

the ribbon section of the form.

Tech part (Data model)

AX 2012 Item AIF Web Service (InventItemService)

Table Name	Table Description
EcoResProduct	The EcoResProduct table stores products and is the base table in the products hierarchy.
EcoResProductMaster	The EcoResProductMaster table stores product masters.
EcoResProductIdentifier	The EcoResProductIdentifier table contains a product identification that is available for users.
EcoResDistinctProduct	The EcoResDistinctProduct table stores products.
EcoResDistinctProductVariant	The EcoResDistinctProductVariant table stores product variants.
EcoResProductDimensionGroup	The EcoResProductDimensionGroup table contains information about a dimension group.
EcoResProductDimensionGroupProduct	The EcoResProductDimensionGroupProduct table stores information about relationships between products and dimension groups.
EcoResColor	The EcoResColor table stores color names.
EcoResSize	The EcoResSize table stores size names.
EcoResConfiguration	The EcoResConfiguration table stores configuration names.
EcoResProductMasterColor	The EcoResProductMasterColor table stores information about colors assigned to product masters.
EcoResProductMasterSize	The EcoResProductMasterSize table stores information about sizes that are assigned to product masters.
EcoResProductMasterConfiguration	The EcoResProductMasterConfiguration table stores information about configurations assigned to product masters.
EcoResProductVariantColor	The EcoResProductVariantColor table stores information about the colors that are assigned to product variants.
EcoResProductVariantSize	The EcoResProductVariantSize table stores information about the sizes that are assigned to product variants.
EcoResProductVariantConfiguration	The EcoResProductVariantConfiguration table stores information about the configurations that are assigned to product variants.
EcoResProductMasterDimensionValue	The EcoResProductMasterDimensionValue table is the base table in the product model dimension hierarchy.
EcoResProductVariantDimensionValue	The EcoResProductVariantDimensionValue table is the base table in the product variant dimension hierarchy.
EcoResProductDimensionAttribute	The EcoResProductDimensionAttribute table contains definitions of product dimension attributes (categories).
EcoResInstanceValue	The EcoResInstanceValue table contains the definitions of the instances of the components or products.
EcoResProductInstanceValue	The EcoResProductInstanceValue table contains definitions of values for the instances of attributes of a product.
InventTable	The InventTable table contains information about items.
InventTableModule	The InventTableModule table contains information about purchase, sales, and inventory specific settings for items.
InventItemLocation	The InventItemLocation table contains information about items and the related warehouse and counting settings. The settings can be made specific based on the items configuration and vary from warehouse to warehouse.
InventItemSalesSetup	The InventItemSalesSetup table contains the default settings for items, such as site and warehouse. The values are related to sales settings.
InventItemInventSetup	The InventItemInventSetup table contains the default settings for items, such as site and warehouse. The values are related to inventory settings.
InventItemPurchSetup	The InventItemPurchSetup table contains the default settings for items, such as site and warehouse. The values are related to purchase settings.
InventItemSetupSupplyType	The InventItemSetupSupplyType table contains information about the sourcing of items.
InventDim	The InventDim table contains values for inventory dimensions.
InventDimCombination	The InventDimCombination table contains variants of items. The variants are created as product variants that are based on product dimensions such as size, color, and configuration. These variants are replicated to the legal entity.

Running batch report in AX2009 (batch printing)

2013-02-06T01:49:00.000-08:00

Since the change of AX2009 batch framework, printing of report through batch can be done through two methods:
- Printing from server (to printer or file)
- Printing from client (the legacy batch processing)

Prerequisites: For both of the method, there're some mandatory setup:

Enable any of the AOS that you want to make it as batch AOS
(Administration -> Setup -> Server configuration)
Create batch group for printing.
Eg. One for client printing and one for server printing.
(Administration -> Setup -> Batch groups)
Add the batch group created in #2 into the AOS enabled for batch processing (in #1)

Printing from server (print to printer)

Enable the 'Allow clients to connect to printers on this server' settings at Dynamics AX Server Configuration Utility under the 'Application Object Server' tab.
Enable the 'Connect to printers on the server' settings at Dynamics AX (client) Configuration Utility under the 'Connection' tab
When printing report
> At the 'Batch' tab, check the 'Batch processing' and select the batch group created for server printing
> Click on the "Option" and select the server printer. Server printers are prefix with 'AOS:'

Printing from server (print to file)

Enable the 'Allow clients to connect to printers on this server' settings at Dynamics AX Server Configuration Utility under the 'Application Object Server' tab.

*Although you're printing to file, but you still need to enable this.
When printing report
> At the 'Batch' tab, check the 'Batch processing' and select the batch group created for server printing
> Click on the "Option" and select 'File', then ensure the file name is a UNC path (Eg.\\serverName\directory) else you'll get an error.

*After this job is added to the batch, you can check it at 'Basic > Inquiries > Batch job'. Click on the 'View tasks', notice that the 'Run location' is "Server". If your 'Run location' is "Client", then you might have selected a client printer or your report class method 'runsImpersonated()' has been overwritten to return "false".

Printing from client (through legacy batch processing)

When printing report
> At the 'Batch' tab, check the 'Batch processing' and select the batch group created for client printing
> Click on the "Option" and select the client printer
Run the legacy batch processing (Basic > Periodic > Batch > Processing)

*After this job is added to the batch, you can check it at Basic > Inquiries > Batch job. Click on the 'View tasks', look at the printing job/task, it will change from "Waiting" to "Ready", then to "Executing". Also notice that the 'Run location' is "Client". The legacy batch processing require the task to be in "Ready" status, this field cannot be changed manually, it is automatically changed if you've done step #3 in the prerequisites (it might not change immediately, give it some time then refresh it and look at the status again).

Some common errors:

Use of printers on the server is not allowed

Resolution: Ensure the 'Allow clients to connect to printers on this server' settings at Dynamics AX Server Configuration Utility under the 'Application Object Server' tab is checked.
Target file must be in UNC format

Resolution: Ensure when you select 'File' as the output, the 'File name' is UNC path. Eg. \\serverName\directory
@"\\SON15882\D$\Test\Cust.txt"

Selected printer is not an AOS printer

Resolution: Install the printer driver on the server.
Sometimes there're confusion regarding AOS printer and shared printer.
For printing to works in batch mode (running from server), the printer has to be AOS printer, which the printer is "Installed" as printer on the AOS host server, not "Connect" as shared printer.

How change the color of a single colum not the entire row

2013-01-10T02:35:00.000-08:00

You can override the displayOption() method of the form's datasource 
to change appearance of any row in the grid. U can set either the 
foreground or the background color of the row.

public void displayOption(Common _record, FormRowDisplayOption _options)
{
   _options.backColor(WinApi::RGB2int(0,255,0)); 
} 

For highlighting one or more cells, override the 

To highlight one or more individual cells, use 
the ._options.affectedElementsByControl() method. 

public void displayOption(Common _record, FormRowDisplayOption _options)
{
  _options.backColor(WinApi::RGB2int(0,255,0));
  _options.affectedElementsByControl(Control1.id());
  _options.affectedElementsByControl(Control2.id());
} 

Remember one thing, u can change multiple cells this way but u cant 
assign different colors to different cells. U have to use only one 
color for any of the cells in the row.

Primary key, Primary Index and Clustured Index

2013-01-08T23:16:00.002-08:00

There are two main types of indexes that we can have on a Microsoft SQL Server backend Database. These are normal and clustered indexes. Normal index can be viewed as the index in the back of a book. We first look in the index for a topic. After finding the topic in alphabetical order we also find the page number or address of the topic in the book. We then use the address to easily find the topic. If we did not have this index we would have to search sequentially through the book and the larger the book the greater the effort and time to either find a topic or realize that it does not exist.

This is similar to a normal index in the database where we have the data stored in one file and the index stored in another file in the order specified. The database engine using the index will first look in the index file then retrieve the address of the record that is used to locate the record in the data file.

For clustered index the records in the data file are sorted in the order of the index. We therefore do not have a separate index file from the data file as we have for normal index. You should also note that it is only possible to have one clustered index per table, since the records may only be sorted in one order at any time. You can have several normal indexes and one clustered index for each table. Clustered indexes are more efficient since the index is the actual data records and hence you do not need to seek in another file after finding the key.

The Primary Index of a table is the main index that is used to uniquely identify records in it. No duplicated values are allowed in this index and all fields in the index are required. You can designate a clustered or normal index as the primary index. Since the primary index is the main index you should gain optimum performance by designating a clustered index for this purpose.

Please note that indexes in general improve performance for search but not for inserts or update, since the overhead of organizing and or writing the index is involved.

The fields in the Primary key uniquely identify records in any given table. Each unique combination ofPrimary key fields uniquely identifies one (and only one) record in the table. Primary keys MUST be unique. There can only be ONE primary key per table. Not all unique indexes are primary keys.

The Clustered index is the physical order in which records are stored in the table. Say you have a clustered index on a text field called "Name", and you insert a record with a name that starts with a letter D, the record will physically be inserted between the C and the E record. Clustered indexes do not have to be unique.

Data Selection and Manipulation in Ax 2009

2013-01-03T23:59:00.001-08:00

You can use SQL statements either interactively or within source code, to access and retrieve data that is stored the database. Data manipulation is performed through the following statements:

insert adds one or more new records into a table.
update modifies data in existing table records.
delete removes existing records from a table.

Before any data can be changed in Microsoft Dynamics AX, the data must first be selected for update by using a select statement. The select forUpdate command selects records exclusively for update.

The insert, update, and delete methods perform operations on only one record at a time. The array insert, insert_recordset, RecordInsertList, and update_recordsetstatements perform operations on multiple records at a time. However, the X++ record-set operations can fall back to record-by-record operations in a number of situations.

For more detail information Go to the :

http://msdn.microsoft.com/en-us/library/aa883417(v=ax.10).aspx

How to get the current active company in AX

2013-01-03T23:55:00.000-08:00

By running the curExt() function the current active company is returned.


static void curExtExample(Args _arg)
{
str s;
;

// Sets s to the extension of the current company.
s = curExt();
print "Current extension is " + s;
pause;
}

Copying data of one table to another table across the company in AX

2013-01-03T23:42:00.000-08:00

//Copying data of one table to another table across the company in AX2009
static void CopyDataFromOneTableToAnother(Args _args)
{
TableA tableA;
TableB tableB;
DataArea dataArea;

;

while select dataArea
{

changeCompany(dataArea.id)
{
tableA= null;
tableB= null;
while select tableA
{
tableB.CustAccount = tableA.CustAccount;
tableB.ItemCode = tableA.ItemCode;
tableB.insert();
}
}
}

info(strfmt("Mission Accomplished"));

}

Run a form automatically when opening dynamics ax

2012-11-06T05:25:00.003-08:00

create menu item for the form and call:

new MenuFunction(menuitemDisplayStr(YourMenuItemName), MenuItemType::Display).run();

Place this code to Info.startupPost() (if you want it to start when the client starts) or Info.workspaceWindowCreated() (if you want it to start every time new workspace is opened).

Microsoft Dynamics AX 2012 Eventing

2012-10-18T04:14:00.000-07:00

Hello Friends,

One of the great new development improvements for Microsoft Dynamics AX 2012 is "Eventing". For most people, that have ever done any Object oriented development or programming, eventing is a concept that most familiar.

You could do event handling in earlier versions too but in AX 2012, event handling is better than previous version. Now it uses the concepts of delegates, event handlers etc...

Everybody must have seen that there are very few customers that use out of the box AX without any customization's I would say not even a single customer. All customers are required to customize AX to fulfill their business needs. Sometimes, customization's become so large that it becomes difficult to upgrade when Microsoft does make changes in the lower layer. Finally, it becomes cost/budget issue so event handling mechanism in AX 2012 will help to lower the cost of developing customization's and then upgrading these customization's.

Events are simple and powerful concept. In daily life, we encounter with so many events. Events can be used to support these programming paradigms.

1) Observation: Generate alerts to see exceptional behavior.

2) Information dissemination: To convey information to right people at right time.

3) Decoupling: Consumer doesn't need to know about producer. Producer and Consumer can be sitting in totally different applications.

Terminology
AX 2012 events are based on .NET eventing concepts.

Producer: Object to trigger the event.

Consumer: Object to consume the event and process logic based on the event triggered.
Event: An action that needs to be triggered
Event Payload: Information that can go along with event.Delegate: Definition that is passed to trigger an event. Basically, communicator between producer and consumer

Things to remember while using Events in AX2012

(1) Delegate keyword to use in delegate method.

(2) Public or any other accessibility specifier is not allowed in a delegate method.

(3) Delegate Method return type must be void.

(4) Delegate Method body must be empty.

(5) A delegate declaration can have the same type of parameters as a method.

(6) Event handlers can run only on the same tier as the publisher class of the delegate runs on.

(7) Handler can be implemented either in X++ or in managed code.

(8) Only static methods are allowed to be event handlers.

(9) Delegate method can’t be called outside class. Basically, events can’t be raised outside class in which event is defined.

(10) Event handlers for host methods can use one of two parameter signatures:

(i) One parameter of the type XppPrePostArgs. Go through all the methods available in XppPrePostArgs.

(ii) The same parameters that are on the host method that the event handler subscribes to.

Now, let me show you how to use events in AX 2012.

1. Let’s create a class Consumer to create EventHandler (sendEmailToCustomer). This will be called once order is shipped so that email can be sent to customer to notify. It has to be static method.

2. Now let’s create Producer class where this event (sendEmailToCustomer) is called using Delegates. Add delegate by right clicking on Producer class > New > Delegate.

3. Change its name to delegateEmail (you can have any name). Parameter should be same as event handler method (sendEmailToCustomer) i.e. of type Email. Notice it has no body and is a blank method.

4. Now drag and drop sendEmailToCustomer method from Consumer class to delegateEmail.

5. Look at properties of EventHandler. You will notice it is pointing to Class Consumer and method sendEmailToCustomer

6. If order is not shipped, I am creating another event handler (errorLog) in Consumer class to log error into error log.

7. Create another delegate method (delegateErrorLog) in Producer class to call this event handler (errorLog)

8. Drag and drop event handler (errorLog) in delegate method (delegateErrorLog) similar to step 4.
9. Now let’s create main method in Producer class to ship order and let’s see how delegates can be used to trigger event handlers.

10. Suppose shipOrder method returns true. Now, if I run this main method, it should go into delegateEmail method and should trigger method sendEmailToCustomer. Let’s run and see the result. 11. Here is the result and it is as expected so it did trigger method sendEmailToCustomer.

11. Let’s suppose shipOrder method returns false. Now, if I run this main method, it should go into delegateErrorLog method and should trigger method errorLog. Let’s run and see the result.

12. Here is the result and it is as expected so it did trigger method errorLog.

13. Handlers can also be added/removed in x++.

Add Handler: It uses += sign

Remove Handler: It uses -= sign.

14. Now, let’s use addStaticHandler in main method. If you see the code, it is calling addStaticHandler before calling delegate method. If we run it and see the result, it should send 2 emails.

15. Here is the result as expected.

7. Similarly if we use removeStaticHandler method instead of addStaticHandler before calling delegate method then it will remove handler and will not send any email.

So, you can see that with the use of delegates and event handlers, it is so easy to trigger events. Also, it will be easy and less time consuming to upgrade it. Suppose if delegates are called from standard methods while doing customizations then it will be so easy to upgrade if standard methods are changed in next release because only 1 liner code of calling delegate method needs to be rearranged and no changes will be required in event handler methods.

Use of Pre and Post event handlers

In AX 2012, any event handler method can dropped in other method. If the property “CalledWhen” is set to “Pre” then it becomes pre event handler. If it is set to “Post” then it becomes post event handler. Pre event handler is called before the method under which it is dropped and Post event handler is called after method ends. These are so powerful that event handler method can be created in new class and can be dropped in any standard or any other method without changing a single line of code and can be set as pre or post event handler as per business need. Suppose, before creating a customer in AX, business need is to do some business logic then logic can be written in pre event handler and can be dropped in insert method of CustTable. Similarly, if there is post logic to be written after customer is created then post event handler can be created and dropped in insert method of CustTable.

Let’s see how pre and post event handler methods can be created and used.

1. Let’s take same example. I added 2 event handler methods in Consumer class.

2. Drag and drop both these event handlers in method sendEmailToCustomer

3. Set property “CalledWhen” to Pre for EventHandler1 and Post for EventHandler2.

4. Now let’s run main method of Producer class again and see the results. It should call EventHandler1 and then sendEmailToCustomer and then EventHandler2.

5. Here is the result as expected.

With use of events, it has opened so many doors and possibilities. Model architecture and events can be integrated which can help if multiple vendors are doing customizations in different models so that it doesn’t impact customizations of other models/vendors. Use of pre and post handlers is so powerful that it can be used without changing a single line of code in original method. Pre or Post handlers can be just dropped in the original method and will be called automatically before (pre handler method) or after (post handler method) original method.

Stay tuned for more on events. I am still exploring the possibilities using events in AX 2012.

Building Lookups - Using a form for lookup building

2012-10-16T04:57:00.000-07:00

In numerous situations, standard, automatic, or even dynamic runtime lookups cannot display the required data. For example, it might be a lookup with tab pages or a search field. In such cases, Dynamics AX offers the possibility to create an AOT form and use it as lookup.

In this recipe, we will demonstrate how to create a lookup using an AOT form. As an example, we will modify the standard customer account lookup to display only active customers.

How to do it...

1. In AOT, create a new form called CustLookup. Add a new data source with the following properties:

Property Value

Name CustTable

Table CustTable

AllowCreate No

AllowEdit No

AllowDelete No

AllowCheck No

OnlyFetchActive Yes

Index AccountIdx

Property	Value
Name	CustTable
Table	CustTable
AllowCreate	No
AllowEdit	No
AllowDelete	No
AllowCheck	No
OnlyFetchActive	Yes
Index	AccountIdx

2. Change the form's following design properties:

Property Value

Frame Border

WindowType Popup

Property	Value
Frame	Border
WindowType	Popup

3. Add a new Grid to the form's design:

Property Value

Name Customers

ShowRowLabels No

DataSource CustTable
4. Add a new StringEdit control to the grid:

Property Value

Name AccountNum

DataSource CustTable

DataField AccountNum

AutoDeclaration Yes

Property	Value
Name	Customers
ShowRowLabels	No
DataSource	CustTable

Property	Value
Name	AccountNum
DataSource	CustTable
DataField	AccountNum
AutoDeclaration	Yes

5. Add another StringEdit control to the grid, right after AccountNum:

Property Value

Name Name

DataSource CustTable

DataField Name

Property	Value
Name	Name
DataSource	CustTable
DataField	Name

6. Add one more StringEdit control to the grid, right after Name:

Property Value

Name Phone

DataSource CustTable

DataField Phone

Property	Value
Name	Phone
DataSource	CustTable
DataField	Phone

7. Add a new ComboBox control to the end of the grid:

Property Value

Name Blocked

DataSource CustTable

DataField Blocked

Property	Value
Name	Blocked
DataSource	CustTable
DataField	Blocked

8. Override the form's init() method with the following code:

public void init()

{;
super();
element.selectMode(AccountNum);
}

9. Override the form's run() with the following code:

public void run()

{
FormStringControl callingControl;
boolean filterLookup;
;
callingControl = SysTableLookup::getCallerStringControl(
element.args());
filterLookup = SysTableLookup::filterLookupPreRun(
callingControl,
AccountNum,
CustTable_ds);
super();
SysTableLookup::filterLookupPostRun(
filterLookup,
callingControl.text(),
AccountNum,
CustTable_ds);
}

10. Finally, override init() of the CustTable data source with the following code:

public void init()

{
Query query;
QueryBuildDataSource qbds;
QueryBuildRange qbr;
;
query = new Query();
qbds = query.addDataSource(tablenum(CustTable));
qbr = qbds.addRange(fieldnum(CustTable, Blocked));
qbr.value(queryvalue(CustVendorBlocked::No));
this.query(query);
}

11. The form in AOT should look like this:
12. Locate the extended data type CustAccount in AOT, and change its property:

Property Value

FormHelp CustLookup

13. To test the results, open Accounts receivable | Sales Order Details and start creating a new sales order. Notice that now Customer account lookup is different, and it includes only active customers:

How it works...

The newly created CurrencyLookup form will replace the automatically generated customer account lookup. It is recommended to append text Lookup to the end of the form name, so that lookups can be easily distinguished from other AOT forms.

In order to make our form lookup looks exactly like a standard lookup, we have to adjust its layout. So, we set form design Frame and WindowType properties respectively to Border and Popup. This removes form borders and makes the form lookup like a true lookup. By setting the grid property ShowRowLabels to No, we hide grid row labels, which are also not a part of automatically generated lookups. Then, we create a grid with four controls, which are bound to the relevant CustTable table fields.

Next, we change the data source properties. We do not allow any data change by setting AllowEdit, AllowCreate, and AllowDelete properties to No. Security checks should be disabled by setting AllowCheck to No. To increase performance, we set OnlyFetchActive to Yes, which will reduce the size of the database result set to only the fields that are visible. We also set the data source index to improve lookup performance.

Now, we need to define which form control will be returned as a lookup value to the calling form upon user selection. We need to specify it manually in the form's init() by calling element.selectMode() with the name of the AccountNumcontrol as argument.

In the form's run(), we simulate standard lookup filtering, which allows user to user * symbol to search for records in the lookup. For example, if the user types 1* into the Customer account control, the lookup will open automatically with all customer accounts starting with 1. To achieve that, we use the filterLookupPreRun() and filterLookupPostRun() methods of the standard SysTableLookup class. Both methods requires calling a control, which we get by using getCallerStringControl() method of SysTableLookup. The first method reads user input and returns true if a search is being performed, otherwise, false. It must be called before the super() in the form's run() and accepts four arguments:

1. The calling control on the parent form.

2. The returning control on the lookup form.

3. The lookup data source.

4. An optional list of other lookup data sources.

The filterLookupPostRun() must be called after the super() in the form's run() and also accepts four arguments:

1. A result value from previously called filterLookupPreRun().

2. The user text specified in the calling control.

3. The returning control on the lookup form.

4. The lookup data source.

The code in the CustTable data source's init() replaces the data source query created by its super() with the custom one. Basically, here we create a new Query object, add a range to show only active customers, and set this object as the new CustTable data source query. This ensures that there are no dynamic links from the caller form's data source.

The value CustLookup in the FormHelp property of the CustAccount extended data type will make sure that this form is opened every time the user opens Customer account lookup.

Property	Value
FormHelp	CustLookup

X++ code to create a customized lookup on form

2012-10-14T22:41:00.001-07:00

Override the lookup method on Formdatasource field(on which you want to show lookup) , and copy the following code to your method.

Comment the super() method in the lookup.

public void lookup(FormControl _formControl, str _filterStr)
{
SysTableLookup sysTableLookup; // systemclass to create //customlookup
Query query;
QueryBuildDataSource qbd;

;
sysTableLookup = SysTableLookup::newParameters(
tablenum(InventTable),
_formcontrol);

// Construct query on the table,
// whose records you want to show as lookup.
query = new Query();
qbd = query.addDataSource(tablenum(InventTable));
qbd.addRange(fieldnum(InventTable,ItemType)).value(SysQuery::value(enum2str
(ItemType::Item)));

// add the fields to the lookup list
sysTableLookup.addLookupfield(fieldnum(InventTable,ItemId));
sysTableLookup.addLookupfield(fieldnum(InventTable,ItemName));

// pass the query as parameter
// system will show the records in the lookup
// as per your query
sysTableLookup.parmQuery(query);
sysTableLookup.performFormLookup();

}

Sales orders – commissions in Ax 2009

2012-08-29T04:29:00.001-07:00

Setup Commission posting

Microsoft Dynamics® AX2009 calculates sales commissions at the sales line level upon invoicing a sales order.

The Commission posting form is used to specify a general ledger account for a commission posting to be debited only during an invoice update, and also as an offset account that is credited. Click Navigation Pane node: Accounts receivable -> Setup -> Commission -> Commission posting. Select ‘Commission’ to setup debit account and ‘Commission offset’ to setup credit account.

Customer groups for commissions

When calculating the commission of a sales line Microsoft Dynamics AX 2009 searches for the related sales representative, item, and customer combination set up in the Commission calculation form. Groups of sales representatives, items, and customers can also be set up in Commission relationships in the Commission calculation form.

Use Commission customer groups (CCG) to integrate groupings of customers into the calculation of commission transactions for sales orders. Notice that CCGs are not necessarily connected to customer groups. Click Navigation Pane node: Accounts receivable -> Setup -> Commission -> Customer groups for commission.

For a commission to be calculated with regard to a specific CCG, the CCG must be associated with a sales order. A CCG can be set up on:

- Customer – Specify the CCG on the Sales order tab in the Customer commission group field. This defaults to the sales order when creating a sales order with this customer.

- Sales order – Specify the CCG on the Setup tab in the Customer group field. Notice that a setting in the sales order overrides the setting from the Customers form.

To link CCG with the customer, click Navigation Pane node: Accounts receivable -> Customer Details. Switch to the Sales order tab on the Customers form. Change Commission Customer Group.

To link sales order with the CCG, click Navigation Pane node: Accounts receivable -> Sales Order Details. Switch to the Setup tab and select ‘Sales group’, select CCG. If you already have selected the group for the customer, it will be populated automatically.

Commission item groups

Use Commission item groups (CIG) to integrate combinations of items into the commission calculation. Notice that although CIGs are completely independent of ordinary item groups Inventory management > Setup > Item groups it might be desirable to group items into CIGs under similar premises. You can’t change CIG in the order line.

To check existing Item groups, open Inventory management -> Setup -> Item groups.

To create new CIG Accounts receivable -> Setup -> Commission -> Item groups.

To link items with CIG, click Navigation Pane node: Inventory management -> Item details, switch to the General tab on the Item form.

Commission sales group

The purpose of grouping employees is broader than the purpose of grouping customers and items for commission agreements. Within the Commission sales group (CSG) is the specification of which employees may receive a commission when a customer associated with the relevant sales group buys certain items.

Click Navigation Pane node: Accounts receivable -> Setup -> Commission -> Sales groups.

Open Sales rep. form. to setup sales representatives (they need to be in the employee table).

You can allocate percentages of both less than 100% and more than 100%. If the amount is more than 100%, a warning message appears. However, the system correctly calculates the amount if this warning is ignored and an over allocation is required.

You can also associate employees with a sales group by clicking Human Resources > Employee Details. Select an employee and click Commission, select the sales group to attach the employee to.

Click Navigation Pane node: Human Resources -> Employee Details. Click the Commission -> Sales groups menu button.

The same effect as creating a Table relation for a sales rep can be created by only attaching one salesperson to the CSG (Contact).

To integrate CSGs into the calculation of sales order commissions, specify a CSG at one of the following levels:

- Customer – Specify the CSG on the Sales order tab in the Sales group field. This defaults to the sales order when creating a sales order with this customer.

- Sales order – Specify the CSG in the Sales group field. This overrides the setting specified on the customer.

- Sales order line – Specify the CSG in the Sales group field. This overrides the customer and sales order settings.

Commission calculation

Click Navigation Pane node: Accounts receivable -> Setup -> Commission -> Commission calculation.

Go to the Setup tab, specify the following options:

The period the commission calculation is valid.
When commission calculation occurs: Before line discount, After line discount or After the total discount.
Whether the commission calculation is based on the contribution Margin or on Revenue earned for the sales order
In the Find next field, specify whether Microsoft Dynamics AX 2009 is to continue searching for more commission agreements for a salesperson. If this option is not selected, any agreements on the Group or All levels, for example, will be suppressed. Microsoft Dynamics AX 2009 searches to find whether there are employees associated with a Sales group who are to receive a commission. It will accumulate commissions for all possible level. The search for a commission calculation agreement moves from specific relations to general – all relations: Table level, Item and Customer combination; Group level combination of Item and Customer combination; - All – which is the general level.
If during the search a specific table relation exists, this overrides a commission calculation setup at the group level and in the same manner as a group setting overrides a general All setting.

View commission transactions

To see created commission transactions, click Navigation Pane node: Accounts receivable -> Customer Details. Click the Inquiries -> Invoice menu button. Commission -> Commission transactions menu button.

To see all of commission transactions posted for employee, click Navigation Pane node: Human Resources -> Employee Details. Click the Commission -> Commission transactions menu button.

Source: Dynamics Ax training materials.

Create Sales Order in Ax 2012 using X++

2012-08-28T00:46:00.000-07:00

Hi,
In this post we will learn the below using X++ :

1) How to Create Sales Order
2) How to Create Sales Order Line
3) How to Post Sales Order

Code :
public static void SalesOrderDemo(Args _s)
{
// Create the Sales Order

SalesTable salesTable;
NumberSeq NumberSeq;
SalesId sid;
SalesLine sl;
SalesFormLetter fl;
;
NumberSeq =NumberSeq::newGetNum(SalesParameters::numRefSalesId() , true);
sid=NumberSeq.num();
salesTable.SalesId = sid;
salesTable.initValue();
salesTable.CustAccount = "1101";
salesTable.initFromCustTable();
salesTable.insert();

//Create the Sales Line with the created Sales Order
sl.SalesId=sid;
sl.ItemId="1101";
sl.CreateLine(NoYes::Yes,NoYes::Yes,NoYes::Yes,NoYes::Yes,NoYes::Yes,NoYes::Yes);

info("Sales Order Created with Line");

//How to Post the Sales Order Invoice

fl=SalesFormLetter::construct(DocumentStatus::Invoice);
fl.update(SalesTable::find(sid));
info("Sales Order Posted");

}

Dynamics AX 2012 Financial Dimensions

2012-08-10T11:28:00.002-07:00

Hi Friends,

Today we will be exploring the new changes related to Financial dimensions in AX 2012.

Earlier versions AX 2009, 4.0 :

In older version System use to limit the creation of dimensions up to 10.
By default 3 dimensions were available in the system namely Department, CostCenter and Purpose.
Technically these dimensions were controlled by Enum SysDimension and an array EDT Dimension.
So If we have 3 enum elements in SysDimension, then its corresponding array elements are stored in dimension EDT and can be referred as Dimension[0], Dimension[1].....
If you would like to store these dimension values against customized table, then simply we were adding the EDT Dimension to that Table. At Form level simply drag and drop field on Group then system use to show all the array elements as string control.

New version AX 2012 (6.0) :

In AX 60, their is no limit to dimension creations. One can create n number of dimensions as per organization requirements.
Technically their is huge change in framework, the way these dimensions used to be created and stored.
Firstly EDT Dimension (array) is deprecated and replaced with DimensionDefault (Int64 RecId).
Financial Dimensions master table Dimension is replaced with DimensionAttribute and DimensionValueDetails.
Now if one wish to store these dimension on your customized table then instead of EDT Dimension one should add DimensionDefault EDT.
At Form level make use of DimensionDefaultingController class to show the available dimensions.

How to access Financial Dimensions values in AX 2012:

In earlier version, accessing dimension values was very simple like
                 CustTable.Dimension[0]    == Department value
                 CustTable.Dimension[1]      == CostCenter value
                 CustTable.Dimension[2]      == Purpose       value

In AX 60, since they have replaced Dimension EDT with RecId DimensionDefault we have to make use of Dimension helper classes to access values.So in CustTable you will find defaultDimension field which stores reference recId for DimensionAttributeSet.

I am referring Customer 1101 in CEU Company, Contoso Demo Data for illustration purpose. Note the dimension values for this customer as shown in below snap.

Refer the code to access the values.

static void DEV_Dimension(Args _args)
{
    CustTable                         custTable = CustTable::find("1101");
    DimensionAttributeValueSetStorage dimStorage;
    Counter i;

    dimStorage = DimensionAttributeValueSetStorage::find(custTable.DefaultDimension);

    for (i=1 ; i<= dimStorage.elements() ; i++)
    {
        info(strFmt("%1 = %2", DimensionAttribute::find(dimStorage.getAttributeByIndex(i)).Name,
                               dimStorage.getDisplayValueByIndex(i)));
    }
}

When you run the job, will see as below

I know that now you might have understood the importance of theses helper classes, they are making our lives easy :)

Cheque Printing functionality in Ax2009

2012-08-08T23:50:00.001-07:00

Cheque Printing in Ax2009 is very simple.Already there are classes and reports available in Ax2009.
Just the matter is change the develop the new report(with the help of existing Cheque reports) and code in classes.
First:
Create a new base enum in ChequeFormType(ex:HDFC)
Scond:
List of classes for Cheque:
1.BankPrintTestCheque(for testing the layout of the cheque)
2.BankChequePrint(is the main class for 'Bank Cheque printing')
3.CustVendCheque(calles when vendor payment and customer payemnt->generate payment)
add the code whereever ChequeFormType enum is used :)-
Third:
dublicate the existing report 'Cheque_DK' and rename.
change the design as per the HDFC Bank layout.

Test ur cheque layout process:-
1. select a perticular bank a/c in bank details form under Bank Module.
2. Click setup button->cheque layout.
3. select cheque number as fixed.Select check form as 'HDFC' then click Print test button.
Note: before testing the print layout for hdfc bank need to develop a new report.

The same report is called when u print the report from the vendor payment journal :)-
good luch

How batch processing works under the hood AX2009

2012-08-07T23:11:00.000-07:00

In this article I am going to explain how batch processing in AX2009 works, I don't mean

how to set up a batch group or any of that kind of thing that you find in the manual,

what I mean is what each AOS is doing in the background to decide how and when to pick

up batches and process and complete them. Understanding this background can help in

advanced batch troubleshooting or development scenarios.

In AX2009 batch processing changed. Now we have AOSes which can run batch processes

directly, if you want to see what's happening with a batch process, it can be more difficult than

in AX3 or AX4 as there is no client sitting there running to look at.

What happens now is that each AOS has a dedicated thread which checks for batches, basically

all this does is calls Classes\BatchRun.ServerGetTask() once every 60 seconds (timing is not

configurable) and if there is any work for that AOS to do then the AOS will pick up a task from here.

I'll give an example of an end-to-end batch process to show what happens where and when:

- A report is sent to batch by a user, it goes into the batch queue in BATCHJOB (header) and

BATCH (the batch tasks).

- Once every 60 seconds each AOS that has been configured for batch processing

(in administration->setup->server configuration) will call the X++ method -

Classes\BatchRun.serverGetTask()

- In serverGetTask() the logic is exposed in X++ so we can all see what happens, this is the

main place that we decide what to pick up for batch processing. Basically it checks if there

is any tasks in the BATCH table waiting for this AOS - based on the batch groups that this

AOS is configured to process, and based on the time that the records in BATCH are due to

be processed (i.e. something processes at 21:00 each day then it won't get picked up until

21:00 despite the fact that the AOS polls every 60 seconds). There are a few stages to this method:

1. First we check if there is a task (a task is a record in BATCH table) ready for us, the query for

this is like this:

select firstonly pessimisticlock RecId, CreatedBy, ExecutedBy, StartDateTime, Status,
        SessionIdx,SessionLoginDateTime, Company, ServerId, Info
    from batch
    where batch.Status == BatchStatus::Ready
    && batch.RunType == BatchRunType::Server
    && (Session::isServer() || batch.CreatedBy == user)
    join Language from userInfo
        where userInfo.Id == batch.CreatedBy
        && userInfo.Enable == true
    exists join batchServerGroup
        where batchServerGroup.ServerId == serverId
            && batch.GroupId == batchServerGroup.GroupId;

2. If a task is returned in step 1 then there's nothing more to do and we start processing that task.

If no task is returned then we look to see if any batch jobs need to be started, the query for this is like this:

 update_recordset batchJob setting
                Status = BatchStatus::Executing,
                StartDateTime = thisDate
            where batchJob.Status == BatchStatus::Waiting
                &&  batchJob.OrigStartDateTime   <= thisDate
            exists join batch
                where batch.BatchJobId == batchJob.RecId
            exists join batchServerGroup
                where batch.GroupId == batchServerGroup.GroupId
                && batchServerGroup.ServerId == serverId;

 

3. After step 2 we will run Classes\batchRun.serverProcessDependencies(). In here something

interesting happens - we see that we use this table "BatchGlobal", this is used as a focal point,

because we might have several AOSes running batch processing in the same environment,

and so for some operations we look to this table to see if another AOS has already done

something, to decide whether the current AOS needs to do it as well or not. For dependencies

we just make sure that another AOS is not doing this in the same second. So if we continue here,

the queries we run to set more tasks (again tasks are just records in the BATCH table) ready for

processing are below - you can see in the queries how we update the status on the BATCH

table records, checking that we only do it for records which are ready and do not have any

constraints that are not completed yet:

//There are no more available tasks and the user is asking for any task.

Search for more tasks with

    //dependencies
    update_recordset batch setting Status = BatchStatus::Ready
    where batch.Status == BatchStatus::Waiting
        && batch.ConstraintType == BatchConstraintType::Or
    exists join batchJob
        where batchJob.Status == BatchStatus::Executing
            && batch.BatchJobId == batchJob.RecId
    exists join constraintsOr
        where constraintsOr.BatchId == batch.RecId
    exists join batchDependsOr
      where
     (
        ((batchDependsOr.Status == BatchStatus::Finished
            && (constraintsOr.ExpectedStatus == BatchDependencyStatus::Finished
                || constraintsOr.ExpectedStatus == BatchDependencyStatus::FinishedOrError))
        || (batchDependsOr.Status == BatchStatus::Error
            && (constraintsOr.ExpectedStatus == BatchDependencyStatus::Error
                || constraintsOr.ExpectedStatus == BatchDependencyStatus::FinishedOrError)))
        && constraintsOr.DependsOnBatchId == batchDependsOr.RecId
     );
    update_recordset batch setting Status = BatchStatus::Ready
    where batch.Status == BatchStatus::Waiting
        && batch.ConstraintType == BatchConstraintType::And
    exists join batchJob
        where batchJob.Status == BatchStatus::Executing
            && batch.BatchJobId == batchJob.RecId
    notexists join constraintsAnd exists join batchDependsAnd
    where
     (
        constraintsAnd.DependsOnBatchId == batchDependsAnd.RecId
        && constraintsAnd.BatchId == batch.RecId
        && ((batchDependsAnd.Status != BatchStatus::Finished && batchDependsAnd.Status != BatchStatus::Error)
            || (constraintsAnd.ExpectedStatus == BatchDependencyStatus::Finished
                && batchDependsAnd.Status == BatchStatus::Error)
                || (constraintsAnd.ExpectedStatus == BatchDependencyStatus::Error
                && batchDependsAnd.Status == BatchStatus::Finished))
     );

4. When this serverProcessDependencies() is complete in step 3 we call again to serverGetOneTask() (same as in step 1), if there were some more tasks set to "ready" in step 3 then we might pick up a task to work on here. Of course if not tasks were "ready" in step 3 then we won't find a task and we'll just do nothing.

- So our report which we sent to batch, if in the steps numbered 1-4 above, we found this record was ready to process, and we picked it up, what happens next inside the AOS kernel is that we start a worker session, which can be thought of a bit like a client session, just without a client, it will have it's own session ID and you'll see the ID recorded against the record in the Batch table. From this point it calls BatchRun.runJobStatic() and actually runs the batch process - this is just normal X++ running the process here. When this runJobStatic() completes we call BatchRun.ServerFinishTask(), which just sets the status of the record in BATCH to either "finished" or "error" (if it failed for some reason).

- Now our batch task is finished - the record in the BATCH table. But the header for this batch, the Tables\BatchJob record is not set to finished yet. For this part there is another background process running every 60 seconds on each AOS which just calls into BatchRun.serverProcessFinishedJobs(). Now we can see in this X++ method what it does - we use this BatchGlobal table again, to make sure that between all AOSes we only check for finished jobs a maximum of once every 60 seconds, if it has been 60 seconds then we will run a whole load of queries (too many to copy here but you can check there to see them) to create the batch history (various tables), set the BatchJob record to finished and delete the completed tasks and constraints.

There are a couple of other background things that happen in the AOS kernel for batch processing:

1. Every 5 minutes it will call to BatchRun.serverCleanUpDeadTasks() - again we use the BatchGlobal table, so that we'll only run this once every 5 minutes between all AOSes. This just sets tasks back to "ready" if the session ID for the worker session (I mentioned this earlier - we create this worker session when we start processing a task) is no longer a valid session - basically if a task fails with an X++ exception, or something like that, then the worker session will end, and if you have configured this batch task to allow some retries, then it's this method which will reset the task for it to have a retry.
2. Every 5 minutes each AOS will check the server settings, to see if it's supposed to process the same batch groups - or if it's not supposed to be a batch server any more, all those settings.

Creating a batch class in Dynamics AX 2009

2012-08-07T22:45:00.000-07:00

For creating a batch class in Dynamics AX we can start from the Tutorial_RunbaseBatch class,
but here is the explanation for understanding all its methods:

In the classDeclaration, we declare any variable that contains user's selection or preferences
(for example, the customer account for launch a customer report). Also, we declare other
variables like dialog fields, auxiliar variables, etc. But, the most important feature here, is the #localmacro.CurrentList declaration. This macro helps you to define which variables you want
to save for running the class in batch mode (when not user interaction is available).

class Tutorial_RunbaseBatch extends RunBaseBatch
{
//Packed variables
TansDate transDate;
CustAccount custAccount;

// Dialog fields
DialogField dlgCustAccount;
DialogField dlgTransDate;

// Current version
// We can different versions for different purposes
#define.CurrentVersion(1)
#define.Version1(1)
#localmacro.CurrentList // Our current variable list for save user's selected values
transDate,
custAccount
#endmacro
}

The macro #define.CurrentVersion(1) and #define.Version1(1) are useful for scaling our class
when we need to change/upgrade it preserving compatibility.

Now two methods: pack and unpack. These methods are used for store and retrieve user's
preferences and perform the batch operation when none user are available (in batch mode).
Here is the point where we use the macro defined previously:

public container pack()
{
    return [#CurrentVersion,#CurrentList];
}

public boolean unpack(container packedClass)
{
    Version version = RunBase::getVersion(packedClass);
;
    switch (version)
    {
        case #CurrentVersion:
            [version,#CurrentList] = packedClass;
            break;
        //case #otherVersion:
            //[version,#CurrentList, #otherList] = packedClass;
            //break;
        default:
            return false;
    }

    return true;
}

Bacause we need to ask the user about preferences for run this object (report,

process, query, etc.), we must implement some methods:

- dialog: for build the custom dialog for prompting user's preferences.

- dialogPostRun: after dialog was created, you can perform other UI tasks here.

- getFromDialog: used for retrive user's preferences (dialog values).

- validate: here, you can perform a validation for any data entered by the user.

public Object dialog()
{
    DialogRunbase       dialog = super();
    ;
 
    // Creation of our custom dialog fields/controls to ask user for preferences
    dlgTransDate = dialog.addFieldValue(typeid(TransDate),transDate);
    dlgCustAccount = dialog.addFieldValue(typeid(CustAccount),custAccount);

    return dialog;
}

public void dialogPostRun(DialogRunbase dialog)
{
;
    super(dialog);
}

public boolean getFromDialog()
{
    ;

    // Retrieving user's preferences
    transDate   = dlgTransDate.value();
    custAccount = dlgCustAccount.value();

    return super();
}

public boolean validate()
{
    // We can perform some validations here
    if (false)
        return checkFailed("");

    return true;
}

Finally, the main method constructs the object from this batch class, and after

prompting user and validation was successful, the run method is called to perform

some task (in batch mode if it was selected):

server static Tutorial_RunbaseBatch construct()
{
    return new Tutorial_RunbaseBatch();
}

public void run()
{
    try
    {
        // Obviously, this code is silly, why show something to nobody?
        // remember, this code is running in batch without user interaction
        info(strfmt("Parameters: %1 for %2", transDate, custAccount));
    }
    catch(Exception::Deadlock)
    {
        retry;
    }
    catch(Exception::UpdateConflict)
    {
        throw Exception::UpdateConflict;
    }
    catch
    {
        throw Exception::Error;
    }
}

static void main(Args args)
{
    Tutorial_RunbaseBatch    tutorial_RunBase;
    ;

    // Instanciating this batch class
    tutorial_RunBase = Tutorial_RunbaseBatch::construct();

    // Prompting user and run if all is ok
    if (tutorial_RunBase.prompt())
        tutorial_RunBase.run();
}

Creating a new Number Sequence for an Existing Module in Ax2009, and Putting it to Use!

2012-07-17T06:08:00.003-07:00

When I first learned how to create a Number Sequence in my Dynamics AX 2009 Development IV Class (80014) in February of 2010, I left with more confusion about the topic than it should have, and I dreaded coming back to work with the prospect of actually having to implement new Number Sequences. However, once I pulled together the precise steps from various books, online documents, and flat out trial-and-error, the task turned out to not be quite as bad as I had originally left the class thinking. I was however dumbfounded as to why no single source (that I was able to find) outlined the exact steps from creating a new Number Sequence to putting it to use in one clean tutorial.

NOTE: Please bear with me in this tutorial; I am going to break naming convention best practices, so that my example is clearer.

The first thing you need to do is determine which module you want/need to create the new number sequence for. For this example, I am going create a new number sequence for the “Accounts Receivable” module. Then take the following steps:

Creating a new Number Sequence for the Accounts Receivable Module

1. Create your Extended Data Type that will be used in your table as your Number Sequence field. For this example we will create a string based Extended Data Typecalled edt_ComplaintId (with a Label property = “Complaint Report”)

2. Next, since we are using the “Accounts Receivable” module, we must modify the proper NumberSeqReference_XXXX Class. Accounts Receivable, actually maps to Customer (or Cust), so we need to make a modification to theNumberSeqReference_Customer class.
We are only concerned with the loadModule() method, and will simply need to add the following code to it:

numRef.dataTypeId = typeId2ExtendedTypeId(typeid(edt_ComplaintId)); numRef.referenceHelp = "Unique key for the Complaint Report"; numRef.wizardContinuous = true;
numRef.wizardManual = NoYes::No;
numRef.wizardAllowChangeDown = NoYes::No;
numRef.wizardAllowChangeUp = NoYes::No;
numRef.wizardHighest = 999999;
this.create(numRef);

3. After compiling and saving your changes, the next step is to use the Number Sequence Wizard to set it up. Click Basic > Setup > Number sequences >Number sequences to open the form where you can manage your Number Sequences.

4. Click on the “Wizard” button, which then should initialize the wizard.

NOTE: If you receive an error at this point telling you “The application already has the required number sequences”, this means that you either did not add the definition to an established NumberSeqReference_XXXX Class' (in this example, the NumberSeqReference_Customer Class)loadModule() method, or you have already run the Wizard and set it up.

5. Once you arrive on the Wizard Welcome screen, click the Next > button.

6. On the following screen, verify that the Module is “Accounts receivable” and theReference is “Complaint Report” (which is the label of our Extended Data Type). TheNumber Sequence code is just an auto-generated value that you can leave as is (Remember this code, so that you can find it in your list of Number Sequences, because you are going to want to make a couple changes to it). Once you have verified the above, click the Next > button.

7. The next screen just gives you an overview, click the Finish button.

8. You should then see your Number Sequence in the list.

9. You will probably want to change the Format to something such as “CR-######”

10. At this point, your Number Sequence is ready for use!

Using the Number Sequence

1. Create a Table and name it tbl_Complaint.

2. Add the edt_ComplaintId Extended Data Type as one of the fields (drag and drop the Extended Data Type directly into the fields of the Table) and name this field ComplaintId.

3. Add the following Method to the tbl_Complaint:

static client server NumberSequenceReference numRefComplaintId()
{
return NumberSeqReference::findReference(typeId2ExtendedTypeId(typeid(edt_ComplaintId)));
}

4. Create a Form called frm_Complaint.

5. Add the tbl_Complaint table to the form’s Data Sources, and name the Data Source ds_Complaint.

6. Add the following Methods to the Form:

public class FormRun extends ObjectRun
{
NumberSeqFormHandler numberSeqFormHandler;
}

NumberSeqFormHandler numberSeqFormHandler()
{
if (!numberSeqFormHandler)
{
numberSeqFormHandler = NumberSeqFormHandler::newForm(Tmt_CallReport::numRefComplaintId().NumberSequence, element, ds_Complaint.dataSource(), fieldnum(tbl_Complaint, ComplaintId));
}
return numberSeqFormHandler;
}

7. Add the following Methods to the ds_Complaint Data Source:

public void create(boolean _append = false)
{
element.numberSeqFormHandler().formMethodDataSourceCreatePre();
super(_append);
element.numberSeqFormHandler().formMethodDataSourceCreate();
}

public void delete()
{
element.numberSeqFormHandler().formMethodDataSourceDelete();
super();
}

public void write()
{
super();
element.numberSeqFormHandler().formMethodDataSourceWrite();
}

8. Your Number Sequence should now function!

Adding Find\Filter functionality on Display method

2012-07-17T06:05:00.001-07:00

Override Context method of Form control which is using display method and provide code for filter. E.g I have done below for PhysicalInvent field of InventOnHandItem form.

void context()
{

int selectedMenu;
real test;
formrun fr;
Args ag;
Itemname strtext;
querybuilddataSource qb1;
queryrun qr;
query q;
PopupMenu menu = new PopupMenu(element.hWnd());
int a = menu.insertItem('Find');
int b = menu.insertItem('Filter');
int c = menu.insertItem('Remove Filter');

selectedMenu = menu.draw();

switch (selectedMenu)
{
case -1:
break;

case a:
ag = new args('SysformSearch');
fr = new formrun(ag);
fr.run();
fr.wait();
strtext = fr.design().controlName('FindEdit').valueStr();
if(strtext)
{
q = inventSum_Ds.query();
qb1 =q.dataSourceTable(tablenum(InventSum));
QB1.addRange(FieldNum(InventSum,PhysicalInvent)).value(SySQuery::value(strtext));
INVENTSUM_DS.query(Q);
INVENTSUM_ds.executeQuery();
}
break;

case b:
InventSum_DS.filter(FieldNum(InventSum,PhysicalInvent),Sysquery::value(InventSum.PhysicalInvent()));
break;

case c :
InventSum_DS.removeFilter();
break;

Default:
break;
}

}

Number Sequence Creation in Ax 2012 For Existing Module

2012-07-06T21:16:00.000-07:00

Here I want to design a form named FirstForm with DataSource FirstTable

I want to create sequence like "AX00001---------AX99999".

Step 1

Create an EDT - String Type

So, I created an EDT named "AXSeqEDT" with label "AX Seq"

Drag into Table(FirstTable)àFields

Step 2

Now create a new Number Sequence

Path for creating num Sequence is

"Module:: Organization administration.......Common.........Number sequences......Number sequences"

Click on New(Number Sequence)

Now number Sequence form will be opened----That contains 4 sections.

Section 1.Identification.....Specify the NumberSeqCode and Name

Section 2.Scope Parameters... Select the Scope from the Dropdown

Section 3.Segments.... Add the constant and alphanumeric (by clicking the add button and selecting from drop down)

Section 4 .General.....Checkmark for continous and Specify the "smallest and largest and Next" Fields

Now Save Ur Settings

Step 3

Now add the Respective manual-code to class - NumberSeqModuleURMODULE

And Table - URMODULEParameters.

So I am creating number sequence based on HRM Module.....So iam using class NumberSeqModuleHRM andTable HRMParameters

Now go to AOT---Classes-NumberSeqModuleHRM---loadModule()

Add the code here...

Note::Here we can add the code seeing the existing implementation

The Added Code is::

/* setup discussion number sequence - it is global */

datatype.parmDatatypeId(extendedtypenum(AXSeqEDT));

datatype.parmReferenceHelp(literalstr("@SYS32633"));

datatype.parmWizardIsContinuous(true);

datatype.parmWizardIsManual(NoYes::No);

datatype.parmWizardIsChangeDownAllowed(NoYes::No);

datatype.parmWizardIsChangeUpAllowed(NoYes::No);

datatype.parmWizardHighest(99999);

datatype.parmSortField(12);

this.create(datatype);

Now Goto AOT---Tables---HRMParameters---methods-----click on new method

Add the code In the New method

Note::Here we can add the code seeing the existing implementation

The Added Code is

static client server NumberSequenceReference numRefAXSeqEDT()

{

return NumberSeqReference::findReference(extendedTypeNum(AXSeqEDT));

}

Step 4

In order to add our newly created number sequence reference to our Module write the following Job and Execute it

Below job is important to run because without it your new number sequence will not be available to number sequence form under Parameters. This is the change in behavior from AX 2009 where all new number sequence loads while restarting the Dynamic AX. In AX 2012 all the number sequence created to system while installation, so restarting the AOS wont effect in loading the new number sequence, that is why it is important to run the job to load new number sequences.

The Code added in The Job is

static void jobName(Args _args)

{

NumberSeqModuleHRM NumberSeqModuleHRM = new NumberSeqModuleHRM();

;

NumberSeqModuleHRm.load();

}

Step 5

After executing the Above Job, our newly created number Sequence reference "AX Seq" will be added to HRM Module----Number sequence setup form

Lets Check it

Now click on Number Sequence and Identify the newly created Number Seq Reference

After Identifying the Number Sequence Reference ----Allot the Number Sequence Code to the Number Sequence Reference.....By selecting from the drop down list

Step 6

Now add the Code in Create method of Forms Datasource methods

Goto-AOT-Forms-FirstForm-Datasources-FirstTable-Methods-Override method(Create)

public void create(boolean _append = false)

{

;

super(_append);

FirstTable.AXSeqEDT = NumberSeq::newGetNum(HRMParameters::numRefAXSeqEDT(),true).num();

}

Step 7

Now save all ur settings.....Now Open our form-FirstForm

Thanks & Regards