Dear Readers,

There are couple of nice videos available to show case the new costing features in Dynamics AX 2012 R3. Enjoy!

1: Microsoft Dynamics AX 2012 R3 – Inventory aging report

Microsoft Dynamics AX 2012 R3 – Inventory aging report

The new inventory aging report works independent of inventory valuation method. It allows users the flexibility of defining aging buckets in preferred intervals and does not distinguish between physical or financial inventory. Aging is computed based on a FIFO algorithm on physical inventory movements. Values in monitory amount are obtained by multiplying with current unit cost as of reporting date

2: Microsoft Dynamics AX 2012 R3 – Price compare report

Microsoft Dynamics AX 2012 R3 – Price compare report​

The Price compare report allow users to analyze the economic consequence of adjusting the current active cost or with a proposed pending cost. The built in breakdown capability provides the option to compare cost at a segregated level, allowing insight to which cost group type or cost group are causing the net change of cost. The report allows comparison of Purchase price, Sales price and Cost

More nice features

There is also a new Role Center available for the Cost Controller persona to get more insights in the cost accounting areas with the Dynamics AX 2012 R3 release. We will cover this topic and more new cool features like Production Flow Variances Insight and Detailed Bom Calculation View in our next posts

The post New costing features in Dynamics AX 2012 R3 appeared first on Microsoft Dynamics 365 Blog.

In Microsoft Dynamics AX 2012 R2 CU6 we expanded the item tracing functionality to provide consolidated, and more actionable, visibility into the source and destination of items and raw materials in the supply chain.

For example, manufacturers can trace items, raw materials, or ingredients back to the vendor, and forward through the production and sale of the finished product.

Item tracing can help manufacturers comply with regulatory requirements, and helps quality officers and production managers analyze and take action to address variances in the quality of products and materials.

Here is a short list of the new capabilities:

• Determine how much of the item or raw material has been shipped, and to which customers.
• Identify any planned shipments that include the item or raw material.
• Locate production orders that use the item or raw material.
• Find out which vendor the item or raw material was purchased from.

There is a more documentation available on TechNet, so please continue reading from there :o).

Enjoy!

Dynamics AX SCM team

Please note, that the basic item tracing functionality was always available inside all previous versions of Dynamics AX and is still available in Microsoft Dynamics AX R2 CU6. The new item tracing functionality is an addition to the existing system, to provide an easier overview of the source and destination of items, and facilitate business actions from one place.

The post New Item Tracing functionality in Microsoft Dynamics AX R2 CU6 appeared first on Microsoft Dynamics 365 Blog.

Introduction

Dynamics AX 2012 provides a new feature that allows you to validate the released product setup and ensure data integrity and overall process readiness. This feature is useful for managing master data and we expect it to be widely used by our partners and customers in order to support the product data life cycle processes, engineering change, approval workflows etc.

Retrospective look at the previous versions of Dynamics AX

Traditionally, the system stores item definition data in one main table (Invent Table). Every time a user creates a new item, a set of mandatory fields must be addressed in order to successfully save the new item definition. This approach looks simple and logical; however, the item definition requires a good overview of all the mandatory settings. Insights into these settings are usually divided between users in multiple departments in an enterprise organization and it usually requires quite a lot of work to coordinate this information. A common approach in order to ensure consistency is to create shared and approved item templates which are strictly controlled and can be re-used across enterprises for the initial item data creation.

Another inconvenience of requiring users to address all mandatory fields relates to in-flexibility since it makes users working with the system less agile and process driven. Say, for example, that an engineering department wants to create a new product definition in the ERP system. There is an urgent need to send product descriptions to the external vendor for the localization and for the creation of marketing materials for the upcoming sales campaign. However, users cannot simply create items with the settings to control the external vendor relation processes. In this case, ALL settings must be defined which includes setup of financial accounts, inventory tracking, reservation rules etc.

Item master data setup enables the core business processes within ERP, so it’s not a surprise that we see a number of partner customizations in this space. If, for example, a company wants to retire an item, the company must ensure that the item cannot be produced or sold any longer within the organization. At the same time, it should be still possible to handle customer returns based on the existing customer agreements. When the item master data setup changes, one would expect some validation mechanism to ensure that the new item master data state is consistent with the user’s expectation. Unfortunately, there is no single centralized place to support such item validation process, so our partners and customers have to introduce such capabilities by themselves.

Why are there no any mandatory product master data fields in Dynamics AX 2012?

With the introduction of the Product Information Management (PIM) module in Dynamics AX 2012 we get an opportunity to remove some of the above described boundaries and to build a more flexible and process-oriented solution. There are a couple of key differences for users who deal with products compared to the previous versions of Dynamics AX:

No mandatory fields

• When you create a new shared product definition, the only property that you must provide is a product number (product ID). Once a new shared product is created, you can continue with the master data setup.

Figure 1 Create new product

• When you release a product to the given legal entity you need not set any company-specific properties.
• When you create a new released product from a legal entity, the only property you have to provide is the product number and the item number. Usually those IDs are bound to the automatic number sequence, so you can create a new released product definition with just one click with the mouse.

Figure 2 Create new released product

Once you have a basic product or released product definition in place, the system allows you to continue with the various master data setup processes such as to define translation, attach documents and images, sync product data to an external solution via existing product-item services etc.

When can my product be used for procurement, sales, and production?

This is a valid question at this point because if there are no mandatory fields anymore, how do I know when my product can used for procurement, sales, production, quotation …?

In order to answer this question let’s focus on process readiness and how the system behaves in Dynamics AX 2012.

There are hundreds if not a thousand different business processes which can be controlled by product master data. The total number of those processes varies from industry to industry and the processes vary a lot based on the end customer business requirements. It’s hard, if not impossible, to predict or know in advance which product master data is required in order to enable each unique business process.

Therefore, in Dynamics AX 2012, every single business process has to, metaphorically speaking, verify all required product master data. In other words, if some master data is not set for a given business process, the system will throw an error and the end user must set the master data before the system can continue.

Example

A user creates an inventory movement journal. The system tries to retrieve all inventory dimensions that should be tracked for the product. If the setup is not complete, the process will fail since the basic pre-requirements are not fulfilled.

Figure 3 Create journal line for product with missing setup

Understanding a product validation feature

The new product validation process has been introduced in order to help assess the overall product data readiness for the main business processes.

As mentioned before, it’s impossible to predict what master data will be required for what process in the system. However, we can definitely focus on the setup that is most essential in order to cover key processes in Dynamics AX 2012.

The product master data validation logic can be triggered from released product list pages and released product details forms. The functionality will verify that the following essential fields are specified for the released product:

• Product storage dimension group
• Product tracking dimension group
• Model group
• Item group

In addition to the previous fields list, the following essential fields have been added to the validation logic to cover the Process Industry for Dynamics AX 2012 Feature Pack:

• Catch weight unit setup for the catch weight enabled products

All these settings can be set on the released product list page which prevents the need to navigate across different places and modules in the system. Users can then leverage one single form to complete all the setup that is required.

When, why and how to run a product validation

We strongly recommend to always validate the product data setup to ensure overall process readiness. This process helps to prevent last minute issues for end users.

Example

• A product manager releases all product data to a legal entity.
• The product manager uses product templates to address the main field values and to execute the validation logic.

You can run validation logic for one or for multiple products and you can apply a product template for multiple products at the same time.

Figure 4 Run a product validation function for multiple products

How to customize the product validation process

The EcoResProductValidationService class holds all the product validation logic. The class gets the number of released product references as an input, runs the validation logic, and reports all validation errors in a standard infolog message.

 1: static void runValidationForReleasedProducts(Args _args)

 2: {

 3:     container                           packedProductsPerCompanyInfo;

 4:     InventTable                         inventTable;

 5:     EcoResProductValidatonDataContract  dataContract = new EcoResProductValidatonDataContract();

 6:     EcoResProductValidatonService       service = new EcoResProductValidatonService();

 7:

 8:     // Find all released product with the itemId pattern like 'production*'

 9:     while select itemId from inventTable

 10:             where inventTable.ItemId like 'production*'

 11:     {

 12:         packedProductsPerCompanyInfo += [[inventTable.ItemId]];

 13:     }

 14:

 15:     if (conLen(packedProductsPerCompanyInfo) > 0)

 16:     {

 17:         // Create service operation data contract class and pass all released product references

 18:         dataContract = new EcoResProductValidatonDataContract();

 19:         dataContract.packedProductsPerCompanyData(SysOperationHelper::base64Encode(packedProductsPerCompanyInfo));

 20:

 21:         // Run validation logic

 22:         service.validateProducts(dataContract);

 23:     }

 24: }

Assume that we need to make sure that all items are produced with a production order for the current manufacturing company. The existing EcoResProductValidator can easily be extended to accommodate such a validation check:

Figure 5 Customization example

Summary

Managing product master data can be a complex and challenging task. We hope that the product information management features in Dynamics AX 2012 can help your organization to deal with some of these challenges. The product validation process is there for you, so please learn how to use it and enhance it if you need to.

Thanks for reading.

The post Understanding the product validation process in Dynamics AX 2012 appeared first on Microsoft Dynamics 365 Blog.

The product release process is part of the product setup in Dynamics AX 2012. Every single product must be released to a legal entity before the system allows you to procure, sell, or produce it.

In some cases, the product release process can fail to release products due to inconsistencies or missing setup. In this post, we will take a look at system capabilities that allow you to troubleshoot the product release process and take action to resolve any issues.

Quick overview of the product release process

The product release process allows you to release multiple products and product variants or, in other words, make multiple products available in various legal entities. This action can be executed from various list pages and detail forms.

If you work with a small number of products, it’s a very quick process to release them to a single legal entity. But in the case of, for example, a new site deployment, it can be a time consuming task to release all products to the new legal entity.

For this scenario, we recommend using a server batch job to execute the product release process in order to avoid extra load on the system during work hours. If issues arise during a batch job execution, the release session concept in Dynamics AX 2012 will help provide you with information about any issues or conflicts. Based on the system reports you can then resolve the issues or conflicts that occurred during the batch job execution.

The release session concept and the release process

The release session is a database persisted object which groups all products that should be released to legal entities. The release session object is automatically created behind the scene when you request to release one or more products.

If all products have been successfully released without any issues, the release session is automatically deleted and no further actions are required for the release product request. However, if issues occurred during the release process, then the release session will remain open with all the individual products that failed during the process. This allows you to troubleshoot the release process, fix the issues and repeat the action without having to select all products and legal entities one more time.

Example

Assume that a product manager must release a new collection of products to a new legal entity. When he executes the release process, various errors are reported by the system. The product manager can now navigate to the most recent release session, troubleshoot the issues and repeat the entire release action from there.

Open product releases list page

All open release sessions can be found under Product Information Management -> Periodic -> Open product releases list page. This list page contains all release sessions where something went wrong. You can filter all sessions by the user ID and release session time stamp to see all the products and product variants that the system could not release to the legal entity.

You can click the View Infolog button to view details about the issues with the specific product or product variant. This is a great way to figure out what went wrong and why.

Let’s take a look at some issues that commonly occur during the product release process:

· The product already exists in a legal entity.

o This can happen if you release a product for the first time by mistake and then release the product again after having made changes to it. This action will create a conflict and one way to solve the conflict would be to delete the released product from the legal entity, go back to your product definition, make the required changes, and then release the product again.

· A different product already exists with the specified item ID.

o This might happen due to an issue with the number sequence for the item number or because the item number has been defaulted from the product number and by coincidence, another released product exists with the same item number. To solve this issue, you must use another number sequence or rename a product with a different product number value.

· The product variant could not be released

o This usually happens when the inventory dimensions (InventDim) number sequence setup is missing in the legal entity. Make sure that the number sequence is properly set up.

When you have investigated and resolved all issues, you can repeat the release action by clicking the Release product button.

Working with the release session from the code

If you have access to the code, you can also release a series of products without using the user interface. The following code example demonstrates how the release session can be created and how it should be used for release purposes:

 1: static void releaseProductToCurrentLegalEntity(Args _args)

 2: {

 3:     EcoResProductReleaseSessionManager  productReleaseSessionManager;

 4:     EcoResProduct                       product;

 5:     CompanyInfo                         companyInfo;

 6:

 7:     companyInfo = CompanyInfo::findDataArea(curext());

 8:

 9:     product = EcoResProduct::findByDisplayProductNumber('myProduct');

 10:

 11:     ttsBegin;

 12:

 13:     // Create a new release session

 14:     productReleaseSessionManager = EcoResProductReleaseSessionManager::newReleaseSession();

 15:

 16:     // Add a product to the release session

 17:     productReleaseSessionManager.addProduct(product.RecId);

 18:

 19:     // Add a legal entity where tne product should be released to 

 20:     productReleaseSessionManager.addLegalEntityForAllProducts(companyInfo.RecId);

 21:

 22:     // Release all products within the current session to the specified legal entity

 23:     productReleaseSessionManager.execute();

 24:

 25:     ttsCommit;

 26: }

Another approach would be to use the existing Product-Item data management services.

Summary

The product release process is an important concept in Dynamics AX 2012. We hope that the tools and functionality of the system sufficiently and effectively support your business process.

The post Troubleshooting the product release process appeared first on Microsoft Dynamics 365 Blog.

Introduction

Dynamics AX 2012 provides a new feature that allows you to create and apply product templates to speed up the product creation process. We believe that this is one out of hundreds of small hidden features that will delight our partners and make our end customers more efficient.

Item record templates in the previous version of Dynamics AX

Traditionally, the Record Templates functionality plays an important role in the user experience during a creation process of key master data entities such as items, customers, and vendors. The system allows you to create a copy of any record in the grid and use it to create a new entity of the same type. This approach helps to ensure data consistency and to establish enterprise process control.

If, for example, you want to create a new engineering component, you can apply a predefined and approved item template that contains data which has been carefully gathered across different departments such as account setup, reservation rules, and dimensions tracking.

Understanding the product templates in Dynamics AX 2012

In Dynamics AX 2012, there is a rich and normalized data model behind key entities such as products and released products. This means that when you create a product, multiple tables get updated behind the scene. Using a template will help you create uniform product master data in a more intelligent manner.

The product template feature in Dynamics AX 2012 takes into account the new data model by extending an old limitation where the template was only associated with one record in one table. Now, the template can build records from multiple tables and records.

Create product templates in Dynamics AX 2012

To create a new product template, navigate to the Released Product Details Form -> Action Pane -> Template menu. Here you can create a snapshot of the current product entity and save it as a shared product template or as a personal product template.

Work with the shared product templates

You find the shared product templates under Home -> Area Page -> Setup -> Record Templates.

You can edit a shared product template at any time. This means that if, for example, you want to use a different counting group for a given predefined product template, then you do not need to create a new product template. You can just update the existing template.

Also, the system allows you to modify the shared product template from the Product details form. This makes it easy to identify all the fields that you want to change.

Apply product templates

Product creation form

You can select a product template when you create a new released product. Key fields in the product structure are populated by the template.

Once you have selected a product template, you can click Show more fields in order to view the important field content that has been provided by the template. You can overwrite template values which are displayed on the form.

Please note, that you can view only the most essential fields in this dialog. Rest fields from the template will be automatically applied during the product creation.

Released Product Details form

You can apply and try to re-apply a template from the Released product details form. Every time you apply a template, the system tries to update the various fields of the released product entity.

If you have applied a wrong template by mistake during product creation you can easily re-apply the proper template to the same product, rather than delete and create a new product. However, the system runs regular validation logic for all updated fields so if a released product is already in use, any attempt to re-apply the template will fail if the product contains data that don’t match the template.

Assume that you have a stocked product with transactions. You try to apply a new version of the template to the product. However, on the template, the Stocked Product policy is not selected which means that products based on the template are non-stocked. In this case, the system will fail during the apply template action. This is because a stocked product with existing inventory transactions cannot be converted to a non-stocked product.

Apply a product template to multiple products in one go

When you release a bulk of products in a legal entity, you can apply a template all the products in one go rather than one by one. From the main Release product list page, you select the products where you want to add the template and click Apply template.

Product templates in Dynamics AX 2012 Feature Pack

As you probably know, the recent feature pack contains new, exiting capabilities within retail and process manufacturing industries. And as you might expect, the product template functionality has been extended to accommodate key product data for those industries as well. You can, for example, create and re-use a template that stores retail-specific released product data.

Summary and some thoughts for the next releases

The product master data creation process is an essential part of any ERP product. Going forward we will do our best to make sure that the system offers more intelligent ways to simplify and streamline the product data creation and maintenance processes.

Please let us know if you have any specific suggestions on how we can improve the product in this area. We encourage you to join the AX SCM requirements LinkedIn group to either let us know what requirements you see in the field or to answer polls that we setup to gather feedback or by setting up your polls/discussions. This is a great way for you to influence the product direction.

The post Using product templates in Dynamics AX 2012 appeared first on Microsoft Dynamics 365 Blog.

What is the purpose of the product number?

This is a common question since the product number is a new concept in Dynamics AX 2012. The main purpose is to have a single, unified identification of a product throughout the entire organization.

In addition to the product number you have a legal entity-specific item number. The item number supports the need to be able to identify products based on numbers that make sense to users within a legal entity.

In this post we will describe the purpose and the use of product numbers and item numbers.

Product number

The new Product information management module in Dynamics AX 2012 allows users to create and manage shared product definition data in a centralized and consistent way. For companies that run a business across multiple legal entities, the concept of shared products can be a help to manage product master data and establish company-wide data governance processes.

For example, consider a company that wants to ensure that the same product data is consistent across different manufacturing plants or retail stores.

The product number is the main product identification (ID) in the system. It helps users to identify or to search for the same product instance across the entire organizational structure. The product number serves as a common reference for company-wide operational and reporting purposes.

In Dynamics AX 2012, a product has to be released to a legal entity before it can be included on a transaction, line or before orders can be created against the product. The release process allows users to control which products become released products in which legal entities.

Item Number

The item number (or item ID) is the legal entity-specific identification of the released product. When a product is released to a legal entity, the item number is aligned with the product number, unless a number sequence exists for the item number in the legal entity.

The system does not validate whether the values are identical or not. So in cases where a specific item number is required in order to identify products within an organization, the item number can be renamed.

For example, some manufacturing companies include the unit of measure in the legal entity-specific item number. In cases where items are consolidated between a legal entity and an acquired organization, it would also be necessary to rename the item number in the legal entity.

Intercompany supply chains and consolidated reporting

For intercompany chains and for consolidated reporting purposes the system always uses a product reference. The system does not take any dependency on the legal entity-specific item numbers. Instead, a shared product reference is used to map intercompany demand and supply during master scheduling or to establish the relationship between the intercompany sales and purchase orders.

Please note that in previous versions of Dynamics AX, the system uses the concept of a company item to allow for intercompany trade between two parties. All items in one company have to be mapped manually to every item in the other company before the intercompany order can be created. With Dynamics AX 2012 there is no longer a need for manual mapping. As long as a product is released to both companies, all intercompany chains can operate smoothly. 

Recommendation regarding intercompany trade

As a general guideline, we recommend that you avoid using the item number for any purposes that are related to intercompany trade. Instead, aim to use the product number for any data consolidation across multiple legal entities.

Please note that in previous versions of Dynamics AX, the system uses the item number as the main reference for entry of orders such as sales orders and production orders. The system also uses the item number to identify inventory transactions. This is unchanged in Dynamics AX 2012.

The post Product Number and Item Number in Dynamics AX 2012 appeared first on Microsoft Dynamics 365 Blog.

Introduction

Those of you who know the Shop floor control module in Dynamics AX 2009 will notice that it is not a separate module in Dynamics AX 2012. This post gives you a quick overview of how to access the Shop floor control functionality in Dynamics AX 2012.

Time attendance and Manufacturing execution

The Shop floor control module has been divided into two feature sets:

• Time and attendance contains functionality to register work time and attendance such as clock-in and clock-out, indirect activities, absences, breaks, overtime, and flextime. It also includes features to generate payroll information that can be used in a payroll system.
• Manufacturing execution allows you to register time and item consumption for a specific production job or project, provide job feedback, do job scheduling and prioritization, etc.

The division of the time and attendance and the job registration functionality provides more flexibility. The licenses for the two feature areas are separate and more users and more industries can now benefit from the functionality that is relevant for their work areas.

The Time and attendance features are moved to the Human resources module and the features can be accessed through the Human resources area page. The related menu items are located in Time and attendance groups under Common, Reports, Inquiries, Periodic and Setup. There is also a Time registration workers list page menu item under the Workers group in the Common area.

The features to clock-in and clock-out and to register time with an electronic timecard are available on the Home area page in the Time and attendance group under Common. These tasks can be performed by any employee and this is the reason why the features are not located in the Human resources or Production control areas.

The menu items for Manufacturing execution are located on the Production control area page in the Manufacturing execution groups under Common, Periodic and Setup and in the Registration group under Inquiries

Disclaimer

All the information about AX 2012 posted here is a pre-release. Any feature is a subject to be changed before the release without notice.
This disclaimer is applicable to all posts about AX 2012 in this blog.

The post Microsoft Dynamics AX 2012: Where is the Shop floor control module? appeared first on Microsoft Dynamics 365 Blog.

Introduction

In this blog entry we will provide guidelines for the use of new and modified product-item data management services.

Product-item data management services

The following services have been created or modified in order to enable manipulation of product-item data. These services are AIF document services so they follow all the conventions applicable to the AIF document services:

 Setup of product services

Product-item services must be enabled on an AIF inbound port before they can be used. All services can be enabled on one port or several ports can be used.

An inbound port can be created in the Inbound ports form (System administration > Setup > Services and Application Integration Framework > Inbound ports). This article illustrates the creation of two ports:

• A port that uses a NetTcp adapter
• A port that uses a File system adapter.

A port that uses a NetTcp adapter can be used to access services programmatically; for example, from a C# application. A port that uses a File system adapter can be used when input data is in the format of an XML document. The following guidelines are based on the use of a default configuration of ports. Advanced configuration of ports is beyond the scope of this article.

Create a port that uses a NetTcp adapter

1. For a new port, specify name and adapter:

2. Click the Service operations button to specify the service operations that are going to be available on the port:

3. In the Select service operations form, select all the product-item service operations:

4. Click the Activate button in the action pane strip to activate the port.

When the port has been activated, a control appears which displays the URI of a WSDL document for the service. This value can then be used for adding a service reference in Visual Studio.

Create a port that uses File system adapter

1. Specify a port name, and from the list of adapters, select File system adapter:

2. In the URI field, specify a path to a folder for incoming XML documents that are to be picked up by the service:

3. Follow the guidelines in the previous procedure to specify the service operations that are going to be available on the port.

4. Click the Activate button in the action pane strip to activate the port.

Now you have two ports with product-item service operations available. Use the following guidelines to create and retrieve data.

Set up Visual Studio

In this article a C# console application project in Visual Studio is used. The only thing that is required here is to create a project and add a service reference for the services:

Create products

All types of products are created by using the EcoResProductService service. However, the methods to create a distinct product, a product master, and a product variant are different so each method is described separately.

Create a distinct product

To create a distinct product, use the EcoResProductService.create operation. First, create a product using C# code, and then create an XML document with data to create a product.

The following code creates a distinct product in Dynamics AX:

static void createDistinctProduct()
{
    AxdEntity_Product_EcoResDistinctProduct distinctProduct = new AxdEntity_Product_EcoResDistinctProduct()
    {
        DisplayProductNumber = "Bulb60W",
        ProductType = AxdEnum_EcoResProductType.Item,
        SearchName = "Bulb60W"
    };
    distinctProduct.Translation = new AxdEntity_Translation[1];
    distinctProduct.Translation[0] = new AxdEntity_Translation()
    {
        LanguageId = "en-us", Name = "Transparent Bulb 60W"
    };
    distinctProduct.Identifier = new AxdEntity_Identifier[1];
    distinctProduct.Identifier[0] = new AxdEntity_Identifier()
    {
        ProductNumber = "Bulb60W"
    };
    distinctProduct.StorageDimGroup = new AxdEntity_StorageDimGroup[1];
    distinctProduct.StorageDimGroup[0] = new AxdEntity_StorageDimGroup()
    {
        Product = "Bulb60W", StorageDimensionGroup = "Std-Dim"
    };
    distinctProduct.TrackingDimGroup = new AxdEntity_TrackingDimGroup[1];
    distinctProduct.TrackingDimGroup[0] = new AxdEntity_TrackingDimGroup()
    {
        Product = "Bulb60W", TrackingDimensionGroup = "Std-Dim"
    };

    AxdEcoResProduct axdProduct = new AxdEcoResProduct()
    {
        Product = new AxdEntity_Product_EcoResProduct[1] { distinctProduct }
    };

    CallContext ctx = new CallContext();
    EcoResProductServiceClient service = new EcoResProductServiceClient();
    try
    {
        service.create(ctx, axdProduct);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

As it appears, the create operation accepts an array of products so it is possible to create multiple products in one call to the service.

The following XML code creates a distinct product. Note that storage and tracking dimension groups are specified. The storage and tracking dimension groups are not mandatory information to create a product so the C# code for the creation of a distinct product does not create these groups.

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
  <Header>
    <Company>DMO</Company>
    <Action>http://schemas.microsoft.com/dynamics/2008/01/services/EcoResProductService/create</Action>
  </Header>
  <Body>
    <MessageParts xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
      <EcoResProduct xmlns="http://schemas.microsoft.com/dynamics/2008/01/documents/EcoResProduct">
        <Product xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" class="entity" xsi:type="AxdEntity_Product_EcoResDistinctProduct">
          <DisplayProductNumber>Bulb40W</DisplayProductNumber>
          <SearchName>Bulb40W</SearchName>
          <ProductType>Item</ProductType>
          <Translation class="entity">
            <LanguageId>en-us</LanguageId>
            <Name>Transparent Bulb 40W</Name>
          </Translation>
          <StorageDimGroup class="entity">
            <Product>Bulb40W</Product>
            <StorageDimensionGroup>Std-Dim</StorageDimensionGroup>
          </StorageDimGroup>
          <TrackingDimGroup class="entity">
            <Product>Bulb40W</Product>
            <TrackingDimensionGroup>Std-Dim</TrackingDimensionGroup>
          </TrackingDimGroup>
          <Identifier class="entity">
            <ProductNumber>Bulb40W</ProductNumber>
          </Identifier>
        </Product>
      </EcoResProduct>
    </MessageParts>
  </Body>
</Envelope>

The EcoResProduct element can contain multiple Product elements in order to create multiple products in one service call.

Create a product master and a related product variant

To create a product master, use the EcoResProductService.create operation. Then use the EcoResProductMasterDimValue.create operation to associate product dimension values with the product master. Finally, use the EcoResProductService.create operation again, this time to create a product variant.

The code to create a product master is basically similar to the code that creates a distinct product. One difference is the code that associates the product master with a product dimension group (in the following example: Size-Dim):

static void createMaster()
{
    //master definition
    AxdEntity_Product_EcoResProductMaster productMaster = new AxdEntity_Product_EcoResProductMaster()
    {
        DisplayProductNumber = "RunningShoe",
        ProductType = AxdEnum_EcoResProductType.Item,
        SearchName = "RunningShoe",
    };
    productMaster.Translation = new AxdEntity_Translation[1];
    productMaster.Translation[0] = new AxdEntity_Translation()
    {
        LanguageId = "en-us", Name = "Comfortable running shoe"
    };
    productMaster.Identifier = new AxdEntity_Identifier[1];
    productMaster.Identifier[0] = new AxdEntity_Identifier()
    {
        ProductNumber = "RunningShoe"
    };

    productMaster.ProductDimGroup = new AxdEntity_ProductDimGroup[1];
    productMaster.ProductDimGroup[0] = new AxdEntity_ProductDimGroup()
    {
        Product = "RunningShoe", ProductDimensionGroup = "Size-Dim"
    };
    productMaster.VariantConfigurationTechnology = AxdEnum_EcoResVariantConfigurationTechnologyType.PredefinedVariants;

    AxdEcoResProduct axdProduct = new AxdEcoResProduct()
    {
        Product = new AxdEntity_Product_EcoResProduct[1] { productMaster }
    };

    CallContext ctx = new CallContext();
    EcoResProductServiceClient productService = new EcoResProductServiceClient();
    try
    {
        productService.create(ctx, axdProduct);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

When the product master is created, associate two size dimension values with the product master (size L and M):

static void createMasterDimensions()
{
    //master dimensions definition (two sizes, L and M)
    AxdEntity_MasterDim_EcoResProductMasterSize sizeDimensionL = new AxdEntity_MasterDim_EcoResProductMasterSize()
    {
        SizeProductMaster = "RunningShoe",
        Size = "L",
        EcoResSize = new AxdEntity_EcoResSize[1] 
        { 
            new AxdEntity_EcoResSize() { Name = "L" }
        }
    };
    AxdEntity_MasterDim_EcoResProductMasterSize sizeDimensionM = new AxdEntity_MasterDim_EcoResProductMasterSize()
    {
        SizeProductMaster = "RunningShoe",
        Size = "M",
        EcoResSize = new AxdEntity_EcoResSize[1] 
        { 
            new AxdEntity_EcoResSize() { Name = "M" }
        }
    };

    AxdEcoResProductMasterDimValue axdDimValue = new AxdEcoResProductMasterDimValue()
    {
        MasterDim = new AxdEntity_MasterDim_EcoResProductMasterDimensionValue[2] { sizeDimensionL, sizeDimensionM }
    };

    CallContext ctx = new CallContext();
    EcoResProductMasterDimValueServiceClient masterDimensionService = new EcoResProductMasterDimValueServiceClient();
    try
    {
        masterDimensionService.create(ctx, axdDimValue);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

Create a product variant with the size L for the product master. One thing that may not be obvious is the value required for the ProductDimensionAttribute field of the AxdEntity_VariantDimValue_EcoResProductVariantConfiguration, the AxdEntity_VariantDimValue_EcoResProductVariantSize, and the AxdEntity_VariantDimValue_EcoResProductVariant entities. The value must correspond to the IDs of the EcoResConfiguration, the EcoResSize, and the EcoResColor tables, respectively.

static void createVariant()
{
    //product variant definition
    AxdEntity_Product_EcoResDistinctProductVariant productVariant = new AxdEntity_Product_EcoResDistinctProductVariant()
    {
        DisplayProductNumber = "RunningShoeL",
        ProductType = AxdEnum_EcoResProductType.Item,
        SearchName = "RunningShoeL",
        ProductMaster = "RunningShoe"
    };
    productVariant.Translation = new AxdEntity_Translation[1];
    productVariant.Translation[0] = new AxdEntity_Translation()
    {    
        LanguageId = "en-us", Name = "Comfortable running shoe L size"
    };
    productVariant.VariantDimValue = new AxdEntity_VariantDimValue_EcoResProductVariantDimensionValue[1];
    productVariant.VariantDimValue[0] = new AxdEntity_VariantDimValue_EcoResProductVariantSize()
    {
        DistinctProductVariant = "RunningShoeL",
        ProductDimensionAttribute = 3173,//The ID of the EcoResSize table
        Size = "L",
        EcoResSize = new AxdEntity_EcoResSize1[1]
        {
            new AxdEntity_EcoResSize1() { Name = "L" }
        }
    };

    AxdEcoResProduct axdProduct = new AxdEcoResProduct()
    {
        Product = new AxdEntity_Product_EcoResProduct[1] { productVariant }
    };

    CallContext ctx = new CallContext();
    EcoResProductServiceClient productService = new EcoResProductServiceClient();
    try
    {
        productService.create(ctx, axdProduct);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

The following XML code does almost the same thing. The only difference is that it creates a product master that is associated with a product dimension group where the Color dimension is active. At first, create a product master:

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
  <Header>
    <Action>http://schemas.microsoft.com/dynamics/2008/01/services/EcoResProductService/create</Action>
  </Header>
  <Body>
    <MessageParts xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
      <EcoResProduct xmlns="http://schemas.microsoft.com/dynamics/2008/01/documents/EcoResProduct">
        <Product xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" class="entity" xsi:type="AxdEntity_Product_EcoResProductMaster">
          <DisplayProductNumber>BoardMarker</DisplayProductNumber>
          <SearchName>BoardMarker</SearchName>
          <ProductType>Item</ProductType>
          <Translation class="entity">
            <LanguageId>en-us</LanguageId>
            <Name>Whiteboard marker</Name>
          </Translation>
          <ProductDimGroup class="entity">
            <Product>BoardMarker</Product>
            <ProductDimensionGroup>Col-Dim</ProductDimensionGroup>
          </ProductDimGroup>
          <Identifier class="entity">
            <ProductNumber>BoardMarker</ProductNumber>
          </Identifier>
          <VariantConfigurationTechnology>PredefinedVariants</VariantConfigurationTechnology>
        </Product>        
      </EcoResProduct>
    </MessageParts>
  </Body>
</Envelope>

Associate values of the Color dimension with the product master:

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
  <Header>
    <Action>http://schemas.microsoft.com/dynamics/2008/01/services/EcoResProductMasterDimValueService/create</Action>
  </Header>
  <Body>
    <MessageParts xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
      <EcoResProductMasterDimValue xmlns="http://schemas.microsoft.com/dynamics/2008/01/documents/EcoResProductMasterDimValue">
        <MasterDim class="entity" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="AxdEntity_MasterDim_EcoResProductMasterColor">
          <ColorProductMaster>BoardMarker</ColorProductMaster>
          <Color>Red</Color>
          <EcoResColor class="entity">
            <Name>Red</Name>
          </EcoResColor>
        </MasterDim>
        <MasterDim class="entity" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="AxdEntity_MasterDim_EcoResProductMasterColor">
          <ColorProductMaster>BoardMarker</ColorProductMaster>
          <Color>Blue</Color>
          <EcoResColor class="entity">
            <Name>Blue</Name>
          </EcoResColor>
        </MasterDim>
      </EcoResProductMasterDimValue>
    </MessageParts>
  </Body>
</Envelope>

Create a product variant:

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
  <Header>
    <Action>http://schemas.microsoft.com/dynamics/2008/01/services/EcoResProductService/create</Action>
  </Header>
  <Body>
    <MessageParts xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
      <EcoResProduct xmlns="http://schemas.microsoft.com/dynamics/2008/01/documents/EcoResProduct">
        <Product xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" class="entity" xsi:type="AxdEntity_Product_EcoResDistinctProductVariant">
          <DisplayProductNumber>BoardMarkerRed</DisplayProductNumber>
          <SearchName>BoardMarkerRed</SearchName>
          <ProductType>Item</ProductType>
          <Translation class="entity">
            <LanguageId>en-us</LanguageId>
            <Name>Whiteboard marker red</Name>
          </Translation>
          <Identifier class="entity">
            <ProductNumber>BoardMarkerRed</ProductNumber>
          </Identifier>
          <ProductMaster>BoardMarker</ProductMaster>
          <VariantDimValue class="entity" xsi:type="AxdEntity_VariantDimValue_EcoResProductVariantColor">
            <DistinctProductVariant>BoardMarkerRed</DistinctProductVariant>
            <ProductDimensionAttribute>3169</ProductDimensionAttribute>
            <Color>Red</Color>
            <EcoResColor class="entity">
              <Name>Red</Name>
            </EcoResColor>
          </VariantDimValue>
        </Product>        
      </EcoResProduct>
    </MessageParts>
  </Body>
</Envelope>

Release products

A product must be released to a company before it can be used in that company. The ItemService and InventDimCombinationService serve this purpose. The former can be used to release distinct products and product masters. The latter can be used to release product variants. A product master must be released before any of its product variants can be released.

Release a distinct product or a product master

The only information required to release a product to a company is the ID of the product and the ID by which it will be represented in the company (ItemId). It is possible to add information to the ItemService service. In the following example, information about units used for storage, purchasing, and selling is provided:

private static void releaseProduct()
{
    AxdEntity_InventTable inventTable = new AxdEntity_InventTable()
    {
        ItemId = "Bulb60W",
        Product = "Bulb60W",
        Invent = new AxdEntity_Invent[1]
        {
            new AxdEntity_Invent()
            {
                ItemId = "Bulb60W", UnitId = "Box"
            }
        },
        Purch = new AxdEntity_Purch[1]
        {
            new AxdEntity_Purch()
            {
                ItemId = "Bulb60W", UnitId = "Box"
            }
        },
        Sales = new AxdEntity_Sales[1]
        {
            new AxdEntity_Sales()
            {
                ItemId = "Bulb60W", UnitId = "Pcs"
            }
        }
    };

    AxdItem item = new AxdItem()
    {
        InventTable = new AxdEntity_InventTable[1] { inventTable }
    };

    CallContext ctx = new CallContext() { Company = "DMO" };
    ItemServiceClient itemService = new ItemServiceClient();
    try
    {
        itemService.create(ctx, item);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

The following XML code releases a product master with the minimum amount of information required:

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
  <Header>
    <Company>DMO</Company>
    <Action>http://schemas.microsoft.com/dynamics/2008/01/services/ItemService/create</Action>
  </Header>
  <Body>
    <MessageParts xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
      <Item xmlns="http://schemas.microsoft.com/dynamics/2008/01/documents/Item">
        <InventTable class="entity">
          <ItemId>BoardMarker</ItemId>
          <Product>BoardMarker</Product>
        </InventTable>
      </Item>
    </MessageParts>
  </Body>
</Envelope>

Release a product variant

A product variant can be released once a related product master has been released. When you release a product variant to a company, the product variant can be identified in two different ways.

• Use the product number of the product variant.
• Use the ID of the associated product master in the company (ItemId) and the InventDim structure with the relevant fields set to the dimension values for the variant (the ItemId/InventDim approach).

For details, see the following examples.

Use the product number of the product variant (DistinctProductVariant):

private static void releaseProductVariants()
{
    AxdEntity_InventDimCombination releasedVariant = new AxdEntity_InventDimCombination()
    {
        DistinctProductVariant = "RunningShoeL",
        ItemId = ""
    };

    AxdInventDimCombination inventDimCombination = new AxdInventDimCombination()
    {
        InventDimCombination = new AxdEntity_InventDimCombination[1] { releasedVariantL }
    };

    CallContext ctx = new CallContext() { Company = "DMO" };
    InventDimCombinationServiceClient inventDimCombinationService = new InventDimCombinationServiceClient();
    try
    {
        inventDimCombinationService.create(ctx, inventDimCombination);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

Use the ItemId/InventDim approach:

private static void releaseProductVariants()
{
    AxdEntity_InventDimCombination releasedVariant = new AxdEntity_InventDimCombination()
    {
        DistinctProductVariant = "",
        ItemId = "RunningShoe",
        InventDim = new AxdEntity_InventDim[1] 
        {
            new AxdEntity_InventDim()
            {
                InventSizeId = "M"
            }
        }
    };

    AxdInventDimCombination inventDimCombination = new AxdInventDimCombination()
    {
        InventDimCombination = new AxdEntity_InventDimCombination[2] { releasedVariantM }
    };

    CallContext ctx = new CallContext() { Company = "DMO" };
    InventDimCombinationServiceClient inventDimCombinationService = new InventDimCombinationServiceClient();
    try
    {
        inventDimCombinationService.create(ctx, inventDimCombination);
    }
    catch (Exception e)
    {
        System.Console.WriteLine(e.Message);
        System.Console.ReadKey();
    }
}

The following XML code releases two variants in one call and uses both approaches to identify a product variant:

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
  <Header>
    <Company>DMO</Company>
    <Action>http://schemas.microsoft.com/dynamics/2008/01/services/InventDimCombinationService/create</Action>
  </Header>
  <Body>
    <MessageParts xmlns="http://schemas.microsoft.com/dynamics/2011/01/documents/Message">
      <InventDimCombination xmlns="http://schemas.microsoft.com/dynamics/2008/01/documents/InventDimCombination">
        <InventDimCombination class="entity">
          <DistinctProductVariant>BoardMarkerRed</DistinctProductVariant>
          <ItemId></ItemId>
        </InventDimCombination>
        <InventDimCombination class="entity">
          <DistinctProductVariant></DistinctProductVariant>
          <ItemId>BoardMarker</ItemId>
          <InventDim class="entity">
            <InventColorId>Blue</InventColorId>
          </InventDim>
        </InventDimCombination>      
      </InventDimCombination>
    </MessageParts>
  </Body>
</Envelope>

Summary

We hope that this blog post will help developers to better understand and use the services for the new product-item data model.

More detailed information regarding the creation and release of products can be found in the Application user Help in the “Product information management” section.

Further developer information about AIF and services can be found on MSDN.

By Wojciech Bardzinski

Disclaimer

All the information about AX 2012 posted here is a pre-release. Any feature is a subject to be changed before the release without notice.
This disclaimer is applicable to all posts about AX 2012 in this blog.

The post Product-item data management services appeared first on Microsoft Dynamics 365 Blog.

With Microsoft Dynamics AX 2012 new capabilities of selling and procuring products, decoupled from inventory control, have been introduced. The purpose of this post is to describe the difference between stocked and non-stocked products of type service and to provide general recommendation about this subject.

Item definitions in Microsoft Dynamics AX 2009 and earlier

Microsoft Dynamics AX 2009 offered the options to define different types of items. The table below illustrates these options:

Service items

Whereas the item types Item and BOM share to a very high degree the same characteristics, the item type service is different.

Services are by definition consumed at the moment they are produced and can therefore not be stocked nor “owned” unlike items.

An example of a service is

The Contoso Company (consumer) has a fleet of company cars. Once a year, the company car must undergo service inspection at a local car shop (producer). The employee will take the company car and “purchase” (consumes) the service at the car shop.

The example illustrates the normal practice for service items. A business has certain services (items of type service) in their inventory, which they would like to, in the above scenario, purchase. The financial value of the service would be posted directly to expense accounts rather than inventory accounts.

In order to support the scenario in Microsoft Dynamics AX 2009 the reference data for such a service item would have to be defined specially for these items.

In the inventory model group, negative physical and financial inventory must be allowed for service items. Furthermore, all ledger integration options, particularly the Post financial inventory must be left blank. This will ensure that, in the example of purchasing the car service, an expense account will be used for receipt transactions.

From an inventory costing perspective, the system does expect service item transactions to be adjusted. Therefore the service items transactions will be excluded during the inventory recalculation process. During the inventory closing run, the service items will be settled according to the special “service item settlement” principle, which will close service item transactions without making any adjustments, therefore will be no additional posting created.

If for some reason whatsoever a service item was to be promoted to become a standard item to be purchased, the system offered the option to change the item type from service to item. This change would have a series of ripple effects, since the core definition of what functions was allowed performed with the previous service item has been changed.

Order management and inventory control management

In Microsoft Dynamics AX 2009 order management and inventory control management were tightly coupled. This resulted in alternate solutions when trying to decouple them.

In the case of procurement, Microsoft Dynamics AX 2009 introduced the purchase requisition function with its concept of non-catalog. The non-catalog concept required a dummy item of type service. This catalog item would be the only item that could be expensed directly without effecting inventory or cost accounting.

To be able to support non-stocked trade for the sales side, you would instead of defining dummy service items, use the free text invoice function next to the sales order function.

Product definitions in Microsoft Dynamics AX 2012

Microsoft Dynamics AX 2012 introduces the concept of shared products. Core product definitions containing key product attributes are defined and controlled without an organizational context. A new product process allows you to release the core product definitions to all or parts of an organization, and finalization of the product data setup is done at the individual organizational level.

The item type in Microsoft Dynamics AX 2009 has been promoted into the product type in Microsoft Dynamics AX 2012. With the new concept the core product types have been revised and so some extend altered. See the table below for reference.

Service products

Defining products of type service in Microsoft Dynamics AX 2012 is fairly simple. Apart from selecting the correct product type, one essential component to remember is to associate the released product in a legal entity with an item model group, where the policy Stocked product is left blank.

This policy is new, and it ensures that products of type service will be expensed and not stocked in inventory.

The following recommendations apply:

As the above matrix illustrates, if a product of type service is to be used both as a standard product offering and included in a BOM cost calculation (for a subcontracting scenario for example), it will require two unique product IDs.

From a master planning and subcontracting perspective, the below constraints dictate that non-stocked service products cannot participate in subcontracting scenarios:

· From Master planning perspective, the non-stocked service product cannot be part of a bill of material. Demand from a higher level bill of material item cannot create drive demand towards a non-stocked product

· From product costing perspective, the non-stocked service product cannot be part of a bill of material and cannot contribute to the direct cost of a finished goods

For a service item to support subcontracting and be included in master planning, the service item has to be setup as stocked.

Regardless of the policy setting in the associated item model group for a product of type service, the inventory storage dimension group will still have to be specified on the product setup. However, only storage dimension site is mandatory for a source document line for a non-stocked service.

Order management and inventory control management

Looking at the service item example from in the beginning of this document, the most noticeable change in Microsoft Dynamics AX 2012 is the ability to decouple order management and inventory control management.

Although products of type service can either be not stocked or stocked (in subcontracting scenarios), the purchase requisition in Microsoft Dynamics AX 2012 no longer requires dummy service items to include in catalogs, because of the new stocked product policy.

The policy now supports to be able to both procure and sell all kinds of products in a consolidated manner, which means on a single order.

Please note that system supports the conversion between stocked and non-stocked services.

Summary

With Microsoft Dynamics AX 2012 new capabilities of selling and procuring, decoupled from inventory control, have been introduced. This non-stocked trade is being supported by a new policy called stocked product on the item model group.

By applying the policy, products of type service can be expensed directly without any use of inventory control processes.

Disclaimer

All the information about AX 2012 posted here is a pre-release. Any feature is a subject to be changed before the release without notice.

This disclaimer is applicable to all posts about AX 2012 in this blog.

The post Service products in Microsoft Dynamics AX 2012 appeared first on Microsoft Dynamics 365 Blog.

The Microsoft Dynamics AX 2012 SCM code upgrade white papers have been available for download on MSDN. Enjoy!

Implementing InventTrans Refactoring – Discusses the refactoring of the InventTrans table and common design patterns. Also discusses how to implement these changes when developing new features or updating existing features.

Implementing the Item-Product Data Management Framework – Highlights the new patterns that are used to represent item-product master data. When detailing the new patterns, the document also describes the pattern that is being replaced and how developers should approach updating their code.

Implementing the Operations Resource Model – Describes new patterns that are used for representing resources, resource capabilities, and resource groups, and provides instruction for upgrading and implementing the new operations resource models.

The post Microsoft Dynamics AX 2012 SCM White Papers: Code Upgrade (InventTrans refactoring, Item-Product Data Management, Operational Resource Model) appeared first on Microsoft Dynamics 365 Blog.