How to: Data Entities: Create a class to export a data entity via a menu item

Example code to export a data entity


/// <summary>
///     Export logic to export and download the target bonus data
/// </summary>
class HRIHcmWorkerTargetBonusEntityExport
{
    DMFQuickImportExport        quickImportExport;
    SharedServiceUnitFileID     sampleFilePath;
    DMFDefinitionGroup          definitionGroup;
    DMFExportImportDataContract exportImportDataContract;

    /// <summary>
    ///     Export logic to export and download the target bonus data
    /// </summary>
    public static void main(Args _args)
    {


        HRIHcmWorkerTargetBonusEntityExport entityExport = new  HRIHcmWorkerTargetBonusEntityExport();

        entityExport.run();

        
    }

    /// <summary>
    ///     Initialise and Run the DMFQuickImportExport object.
    /// </summary>
    public void run()
    {
        str dmfGroupName = 'WorkerTargetBonusExport';
        #DMF

        this.buildQuickExport(tablePName(HRIHcmWorkerTargetBonusEntity), dmfGroupName);
        this.addEntityForProcessing();
        this.runExport();
        info("@HitachiHRIS:HRIInfoSuccessfull");
    }

    /// <summary>
    ///     Create DataProject and entities if not present as per the _dmfGroupName and _entityName
    /// </summary>
    private void buildQuickExport(DMFEntityName _entityName, DMFDefinitionGroupName _dmfGroupName)
    {

        quickImportExport = DMFQuickImportExport::construct();
        quickImportExport.parmDefinitionGroupName(_dmfGroupName);
        quickImportExport.parmEntityName(_entityName);
        quickImportExport.parmSkipStaging(NoYes::No);
        quickImportExport.parmRefreshType(DMFRefreshType::FullPush);
        quickImportExport.parmExportToFile(true);
        quickImportExport.parmFieldGroup("@ApplicationFoundation:DMFExportOperation");
        quickImportExport.parmShowDetails(true);
        quickImportExport.parmExecuteTarget(true);
        quickImportExport.parmSourceName('CSV');
    }

    /// <summary>
    ///     Run the DMFQuickImportExport object.
    /// </summary>
    //Run the DMF export functionality
    private void runExport()
    {
        DMFDefinitionGroupExecution definitionGroupExecution;
        Args exportArgs;
        
        //Run the Dataproject
        exportImportDataContract = new DMFExportImportDataContract();
        Args args = new Args();
        args.record(DMFDefinitionGroup::find(quickImportExport.parmDefinitionGroupName()));

        // Pass exportImportDataContract data contract object
        exportImportDataContract.parmIsAsyncExecution(NoYes::No);
        exportImportDataContract.parmGenerateDataPackage(NoYes::Yes);
        exportImportDataContract.parmReExecute(NoYes::Yes);
        args.parmObject(exportImportDataContract);

        new MenuFunction(menuItemActionStr(DMFExportImportData), MenuItemType::Action).run(args);

        //select the entity definitionGroupExecution
        select firstonly definitionGroupExecution
            order by CreatedDateTime desc
            where definitionGroupExecution.DefinitionGroup == quickImportExport.parmDefinitionGroupName()
            && definitionGroupExecution.Entity == quickImportExport.parmEntityName();

        //Download the dataproject package
        exportArgs = new Args();
        exportArgs.record(definitionGroupExecution);
        new MenuFunction(menuItemActionStr(DMFDownloadDataPackage), MenuItemType::Action).run(exportArgs);
    }

    /// <summary>
    ///     Adds the entity for processing
    /// </summary>
    //Run the DMF export functionality
    private void addEntityForProcessing()
    {
        JPMDMFBatch::addEntityForProcessing(quickImportExport.parmDefinitionGroupName(),
                                                quickImportExport.parmDefinitionGroupName(),
                                                quickImportExport.parmEntityName(),
                                                quickImportExport.parmSourceName(),
                                                quickImportExport.parmFilePath(),
                                                quickImportExport.parmFieldGroup(),
                                                quickImportExport.parmSkipStaging(),
                                                quickImportExport.parmExportToFile(true),
                                                '',
                                                false,
                                                quickImportExport.parmRefreshType());
    }
You can use DMFBatch here but it will popup a message asking if you want to generate the mapping.
}

Here is the rewritten DMFBatch class to remove the popup messages

using DataManagementSerialization = Microsoft.Dynamics.AX.Framework.Tools.DataManagement.Serialization;
using Microsoft.Dynamics.BusinessPlatform.SharedTypes;
using Microsoft.Dynamics.ApplicationFoundation.DIXF.Instrumentation;

class JPMDMFBatch
{
    /// <summary>
    /// Create a definition group and definition group entity and source mapping
    /// if they do not exist for the current definition group
    /// </summary>
    /// <param name = "definitionGroupName">Definition group name</param>
    /// <param name = "description">Description</param>
    /// <param name = "entity">Entity name</param>
    /// <param name = "source">Source name</param>
    /// <param name = "sampleFile">Sample file</param>
    /// <param name = "fieldGroup">Field group name</param>
    /// <param name = "_skipStaging">Staging should be skipped ot not</param>
    /// <param name = "exportToFile">Operation type is export or not</param>
    /// <param name = "sheetLookup">Sheet lookup if source is excel</param>
    /// <param name = "RunInBatch">remove user interaction requests if set to true</param>
    public static void addEntityForProcessing(DMFDefinitionGroupName definitionGroupName,
        Description             description,
        DMFEntityName           entity,
        DMFSourceName           source,
        SharedServiceUnitFileID sampleFile,
        str                     fieldGroup,
        NoYes                   _skipStaging,
        NoYes                   exportToFile,
        DMFSheetLookup          sheetLookup = '',
        NoYes truncateEntityData = NoYes::No,
        DMFRefreshType          _refreshType = DMFRefreshType::IncrementalPush,
        boolean                 RunInBatch = true)
    {
        DMFDefinitionGroup          dmfDefinitionGroupLocal;
        DMFDefinitionGroupEntity    dmfDefinitionGroupEntityLocal;
        DMFEntity                   dmfEntityLocal;
        DMFDataSource               dmfDataSourceLocal;
        DMFDataSourceProperties     sourceProperties;
        boolean                     mapResult = true;
        ttsbegin;

        // Find definition group and insert if not exists - only if this is
        // not the load existing data project scenario
        dmfDefinitionGroupLocal = DMFDefinitionGroup::find(definitionGroupName, true);
        if(!dmfDefinitionGroupLocal)
        {
            dmfDefinitionGroupLocal.DefinitionGroupName = definitionGroupName;
            dmfDefinitionGroupLocal.Description = description;
            if(exportToFile)
            {
                dmfDefinitionGroupLocal.OperationType = DMFOperationType::Export;
            }
            else
            {
                dmfDefinitionGroupLocal.OperationType = DMFOperationType::Import;
                dmfDefinitionGroupLocal.TruncateEntityData = truncateEntityData;
            }
            dmfDefinitionGroupLocal.insert();
        }

        if (source != enum2Str(DMFSourceType::Package))
        {
            // Find entity
            dmfEntityLocal = DMFEntity::find(entity);

            select firstonly Type from dmfDataSourceLocal where dmfDataSourceLocal.SourceName == source
                join FileFormat from sourceProperties where sourceProperties.Source == dmfDataSourceLocal.SourceName;

            // Find datasource
            dmfDataSourceLocal = DMFDataSource::find(source);
            
            // If definition group entity. Create if not exists
            dmfDefinitionGroupEntityLocal = DMFDefinitionGroupEntity::find(definitionGroupName, entity, true);
            if(!dmfDefinitionGroupEntityLocal)
            {
                DMFRefreshType refreshType;
                dmfDefinitionGroupEntityLocal.initValue();
                dmfDefinitionGroupEntityLocal.DefinitionGroup = dmfDefinitionGroupLocal.DefinitionGroupName;
                dmfDefinitionGroupEntityLocal.Entity = entity;
                dmfDefinitionGroupEntityLocal.Source = source;
                dmfDefinitionGroupEntityLocal.SkipStaging = _skipStaging;
                dmfDefinitionGroupEntityLocal.DefaultRefreshType = _refreshType;
                dmfDefinitionGroupEntityLocal.insert(true);
            }
            
            // Set file name. This handles scenarios where data project is reused or when updating
            // an existing one with new entity or when adding a new one in a new data project
            switch (dmfDataSourceLocal.Type)
            {
                case DMFSourceType::File:
                    dmfDefinitionGroupEntityLocal.SampleFilePathOriginal = sampleFile;
                    dmfDefinitionGroupEntityLocal.SampleFilePath = dmfDefinitionGroupEntityLocal.applyTransforms(sampleFile);
                    if (dmfDefinitionGroupEntityLocal.SampleFilePath != dmfDefinitionGroupEntityLocal.SampleFilePathOriginal)
                    {
                        dmfDefinitionGroupEntityLocal.IsTransformed = NoYes::Yes;
                    }

                    if (sourceProperties.FileFormat == DMFFileFormat::EXCEL)
                    {
                        dmfDefinitionGroupEntityLocal.ExcelLookUp = sheetLookup;
                    }
                    break;
                case DMFSourceType::ODBC:
                    dmfDefinitionGroupEntityLocal.QueryForODBC = sampleFile;
                    break;
            }
            
            // For export (or if source is Ax)
            if(exportToFile || dmfDataSourceLocal.Type == DMFSourceType::Ax)
            {
                dmfDefinitionGroupEntityLocal.QueryForODBC = '';
                if(dmfDefinitionGroupEntityLocal.QueryData == conNull())
                {
                    dmfDefinitionGroupEntityLocal.QueryData = DMFUtil::getDefaultQueryForEntity(dmfEntityLocal.EntityName, definitionGroupName);
                }
            }
            dmfDefinitionGroupEntityLocal.write();
            ttscommit;
            
            if (dmfEntityLocal &&
                dmfDefinitionGroupEntityLocal &&
                dmfDataSourceLocal.ApplicationType != DMFSourceApplicationType::Connector &&
                sourceProperties &&
                sourceProperties.FileFormat == DMFFileFormat::XML &&
                sampleFile &&
                dmfEntityLocal.EntityType == DMFEntityTypes::Entity)
            {
                mapResult = DMFQuickImportExport::validateXML(dmfDefinitionGroupEntityLocal.Source,
                    dmfDefinitionGroupEntityLocal.SampleFilePath,
                    dmfDefinitionGroupEntityLocal.Entity,
                    dmfDefinitionGroupEntityLocal);
            }

            // Generate mapping
            if(mapResult && dmfEntityLocal && dmfDefinitionGroupEntityLocal && dmfDataSourceLocal.Type != DMFSourceType::Ax)
            {
                HRIDMFBatch::generateMapping(dmfDefinitionGroupEntityLocal, RunInBatch, fieldGroup);
            }
            ttsbegin;

            // Update mapping status
            dmfDefinitionGroupEntityLocal.reread();
            mapResult = dmfDefinitionGroupEntityLocal.updateMappingStatus();

            // If export then ensure we reset the file
            //path after the source xml map is generated and is valid
            if(mapResult && (exportToFile || dmfDataSourceLocal.Type == DMFSourceType::Ax))
            {
                dmfDefinitionGroupEntityLocal.selectForUpdate(true);
                dmfDefinitionGroupEntityLocal.SampleFilePath = '';
                dmfDefinitionGroupEntityLocal.write();
            }

        }
        ttscommit;

        if (source == enum2Str(DMFSourceType::Package))
        {
            DMFPackageImporter packageImporter = new DMFPackageImporter();
            packageImporter.importFromPackage(DMFStagingWriter::getDownloadURLFromFileId(sampleFile), definitionGroupName, '' ,false, true, curExt(), '', false, sampleFile);
        }
    }

    public static void generateMapping(DMFDefinitionGroupEntity _definitionGrpEntity, boolean RunInBatch = false, FieldGroupName _fieldGroup = '', boolean showErrorMessages = true, boolean showSuccessMessages = true)
    {
        DMFDataSource                   dataSource;
        DMFEntity                       entity, dmfEntity;
        int                             counter = 1;
        boolean                         isFromScratch, noUserInteraction,
                                        xmlComposite;
        container                       con;
        DMFSourceXMLToEntityMap         dMFSourceXMLToEntityMapLoc;
        DMFDefinitionGroupEntity        dmfDefinitionGroupEntity;
        DMFDataSourceProperties         dmfDataSourceProperties;
        DMFStagingConversionTable       stagingConversionTable;
        DMFLocalFilePath                localFilePath;
        SharedServiceUnitFileID         fileId;

        select firstOnly Type from dataSource
            where dataSource.SourceName == _definitionGrpEntity.Source
                join FileFormat from dmfDataSourceProperties where
                    dmfDataSourceProperties.Source == dataSource.SourceName;
        
        noUserInteraction = RunInBatch;
        isFromScratch = false;
        if(!RunInBatch)
        {
            noUserInteraction = dataSource.Type == DMFSourceType::EntityDB ? true : false;
        }

        if (dataSource.Type == DMFSourceType::File && _definitionGrpEntity.SampleFilePath)
        {
            fileId = _definitionGrpEntity.SampleFilePath;
        }
        if (fileId || _fieldGroup || dataSource.Type == DMFSourceType::ODBC || dataSource.Type == DMFSourceType::EntityDB)
        {
            if (fileId)
            {
                if(dataSource.Type == DMFSourceType::File &&
                    (dmfDataSourceProperties.FileFormat == DMFFileFormat::Delimited ||
                     dmfDataSourceProperties.FileFormat == DMFFileFormat::FixedWidth))
                {
                    con = DMFXmlGeneration::flatFileMappingGeneration(_definitionGrpEntity.Source, fileId, _definitionGrpEntity.Entity);
                }
                else if(dataSource.Type == DMFSourceType::ODBC)
                {
                    con = DMFXmlGeneration::odbcMappingGeneration(_definitionGrpEntity.Source,_definitionGrpEntity.QueryForODBC);

                }
                else if(dataSource.Type == DMFSourceType::File && dmfDataSourceProperties.FileFormat == DMFFileFormat::XML)
                {
                    if (DMFEntity::find(_definitionGrpEntity.Entity).EntityType == DMFEntityTypes::CompositEntity)
                    {
                        con = DMFXmlGeneration::xmlMappingGenerationForComposite(_definitionGrpEntity,fileId,_definitionGrpEntity.Entity);
                        xmlComposite = true;
                    }
                    else
                    {
                        con = DMFXmlGeneration::xmlMappingGeneration(_definitionGrpEntity.Source,fileId,_definitionGrpEntity.Entity, _definitionGrpEntity.EntityXMLName);
                    }
                }
                else if (dataSource.Type == DMFSourceType::File && dmfDataSourceProperties.FileFormat == DMFFileFormat::EXCEL)
                {
                    con = DMFXmlGeneration::excleMappingGeneration(fileId,_definitionGrpEntity.ExcelLookUp);
                }
            }
            else if (dataSource.Type == DMFSourceType::EntityDB)
            {
                con = DMFEntityDBExporter::entityDbMappingGeneration(_definitionGrpEntity.Entity, _definitionGrpEntity.Source);
                isFromScratch = true;
            }
            if (_fieldGroup)
            {
                con = DMFSourceXMLToEntityMap::getFields(_definitionGrpEntity.DefinitionGroup,_definitionGrpEntity.Entity, _fieldGroup);
            }
            if (!xmlComposite)
            {
                if (DMFEntity::find(_definitionGrpEntity.Entity).EntityType == DMFEntityTypes::CompositEntity)
                {
                    while select EntityName from dmfEntity
                        where dmfEntity.ParentEntityName == DMFEntity::find(_definitionGrpEntity.Entity).EntityName
                    {
                        select firstOnly RecId from dMFSourceXMLToEntityMapLoc
                            where dMFSourceXMLToEntityMapLoc.DefinitionGroup   == _definitionGrpEntity.DefinitionGroup
                               && dMFSourceXMLToEntityMapLoc.Entity            == dmfEntity.EntityName;

                        if (dMFSourceXMLToEntityMapLoc.RecId)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    select firstOnly RecId from dMFSourceXMLToEntityMapLoc
                        where dMFSourceXMLToEntityMapLoc.DefinitionGroup   == _definitionGrpEntity.DefinitionGroup
                            && dMFSourceXMLToEntityMapLoc.Entity == _definitionGrpEntity.Entity;
                }

                select firstonly EntityName, EntityType from entity
                    where entity.EntityName == _definitionGrpEntity.Entity;

                if (!noUserInteraction)
                {
                    if (dMFSourceXMLToEntityMapLoc.RecId && Box::yesNo("@DMF:DMFGenerateMappingFromScratch", DialogButton::Yes) == DialogButton::Yes)
                    {
                        isFromScratch = true;
                    }
                    else if (!dMFSourceXMLToEntityMapLoc.RecId)
                    {
                        isFromScratch = true;
                    }
                    else
                    {
                        isFromScratch = false;
                    }
                }
                if (isFromScratch)
                {
                    delete_from StagingConversionTable
                        where StagingConversionTable.DefinitionGroup == _definitionGrpEntity.DefinitionGroup
                           && StagingConversionTable.Entity ==  _definitionGrpEntity.Entity;
                }
                if (conlen(con))
                {
                    if(entity.EntityType==DMFEntityTypes::CompositEntity)
                    {
                        DMFEntity childEntity;
                        while select Entity, Sequence from dmfDefinitionGroupEntity order by Sequence asc
                            where dmfDefinitionGroupEntity.DefinitionGroup == _definitionGrpEntity.DefinitionGroup
                        exists join childEntity
                            where childEntity.EntityName == dmfDefinitionGroupEntity.Entity
                               && childEntity.ParentEntityName == _definitionGrpEntity.Entity
        
                        {
                            con = DMFSourceXMLToEntityMap::getFields(_definitionGrpEntity.DefinitionGroup,dmfDefinitionGroupEntity.Entity, _fieldGroup);

                            DMFSourceXMLToEntityMap::generateDefaultMappingFromFile(_definitionGrpEntity.DefinitionGroup,
                                                                                    DMFEntity::find(dmfDefinitionGroupEntity.Entity).EntityName,
                                                                                    conPeek(con,counter),
                                                                                    entity.EntityType,
                                                                                    isFromScratch,
                                                                                    showErrorMessages,
                                                                                    showSuccessMessages);
                        }
                    }
                    else
                    {
                        DMFSourceXMLToEntityMap::generateDefaultMappingFromFile(_definitionGrpEntity.DefinitionGroup,
                                                                                _definitionGrpEntity.Entity,
                                                                                conPeek(con,counter),
                                                                                entity.EntityType,
                                                                                isFromScratch,
                                                                                showErrorMessages,
                                                                                showSuccessMessages);
                    }
                }
            }
        }
        else
        {
            throw error("@DMF499");
        }
    }

}

Comments

Post a Comment

Popular posts from this blog

AX7/D365/Operations: Enable/Disable form control in X++

https://dynamicsaxinsight.wordpress.com/2017/09/12/ax7-d365-operations-enable-disable-form-control-in-x-plus-plus/ Purpose: The purpose of this document is to demonstrate how we can enable/disable a form control in X++ based on a business logic. Product: Dynamics 365 for Finance and Operations, Platform Update 9. Development approach: Customization through extension. Development: Create a post event handler of a standard form method enabling/disabling the form controls. In this case, we are creating a post event handler of a standard method setFieldAccessHeader of SalesQuotationProjTable form. Please find the event handler method definition as follows. [PostHandlerFor(formStr(SalesQuotationProjTable), formMethodStr(SalesQuotationProjTable, setFieldAccessHeader))] public static void SalesQuotationProjTable_Post_setFieldAccessHeader(XppPrePostArgs args) { FormRun sender = args.getThis(); FormDataSource salesQuotationTable_ds; SalesQuot...
Read more

AX 2012: Multi-Select Lookup for SSRS Report Dialog

Image
AX 2012: Multi-Select Lookup for SSRS Report Dialog https://dynamicsaxinsight.wordpress.com/2014/12/12/ax-2012-multi-select-lookup-for-ssrs-report-dialog/   muhammadanaskhan     Development (AX 2012) ,  Dynamics AX 2012 ,  SSRS Reports ,  Technical (AX 2012)     December 12, 2014   2 Minutes Overview: In this post we’ll learn how to build multi-select lookup for SSRS report dialog. We’ll create an RDP report with an AutoDesign layout. Controller will be used to run the report. An output menu item will be created to point to the controller class. Each AOT element involved will be described in detail. You can guess the complexity of this development task by looking at the AOT elements required for it: Let’s develop them piece by piece… 1. MAKCustTable (Query): 1. Create MAKCustTable query. 2. Drag CustTable table to the data sources node. 3. Select the fields as shown in the picture. 2. Tm...
Read more