Циклическая структура и повторное использование EntityNew

Question

Я только недавно начал использовать ORM, так что будьте готовы к тому, что это будет простой ответ ...

Итак, я исключил любую проверку ошибок и определение параметров, и др.Это часть кода, которая добавляет пользователя в базу данных.Сущность заполняется правильно, все работает, кроме!Я получаю одну и ту же запись тысячи раз.Если я заменяю код Entity ORM на writeOutput, я получаю то, что ожидается, но с добавленной обратно формой становится практически бесконечным циклом и никогда не обновляет значения сущности.Я полагаю, что это концептуальный недостаток с моей стороны.
Мысли?

    companyObj = EntityLoadByPK( 'companyInfo', companyId );
    for(i=1; i LTE application._.size(toCommit); i = i++ ){
        /**Again, error checking and defining parameters were pulled out for clarity.  
        It's all about the ORM.[I've got to assume]*/

        structClear(currentEntity);
        StructClear( toSaveObjects );

        currentUserName = structFind(toCommit[i],'USERNAME');
        currentEntity = EntityNew( "CompanyUsers");
        currentEntity.setCompanyId(companyObj);

        try{
            properties = getMetaData(currentEntity).properties;
            for(t=1; t <= arrayLen(properties); t++){
                property        = properties[t];
                currentField    = #property.Name#;
                if( StructkeyExists(toCommit[i],property.name)){
                    currentSetValue = structFind(toCommit[i],property.name);
                    if( LEN( TRIM( currentSetValue ) ) ){
                        if( ListFindNoCase( listOfKeys, TRIM( currentField ), "," ) ){
                            if( ListFindNoCase( toCommitOwnFunction, TRIM( currentField ), "," ) ){
                                <! ---[] Requires separate fuction --->
                                if(currentField eq 'userGroups'){
                                    groupObj = EntityLoadByPK( 'companyGroups', 1);
                                    entity_groupObject = EntityNew('companyUsers_J_companyGroups');
                                    entity_groupObject.setUserId(currentEntity);
                                    entity_groupObject.setGroupId(groupObj);
                                }
                            } else{
                                /***BTW, the duplication occurs even if the fields values aren't assigned dynamically.*/
                                evaluate("currentEntity." & "set#property.name#(currentSetValue)");
                            };
                        };
                    };
                };
            };

            transaction {
                EntitySave(currentEntity);
                if(IsDefined('groupObj')){
                    EntitySave(groupObj);
                };
                transactionCommit();
            };
            committedData.message[i]    = TRIM( mssgQualifier ) & TRIM( mssgValue );
        }
        catch(any e){
            committedData.message[i]    = TRIM( mssgQualifier ) & ' failed.  No further information is available.';
        }
    }
    return committedData;
};

Итак, я попытался очистить приведенный выше код.Я также столкнулся с OrmEvictEntity, который решает основную проблему, с которой я столкнулся.

private function commitStruct( required any toCommit, required string toCommitOwnFunction, string shrtName, any companyId ){

    // Struct Key List.  May vary by record
    var listOfKeys              = '';
    // ORM object to save.  Create for clearing at loop head
    var currentEntity           = structNew();
    // anncillary/related obcts to save with entity
    var entityObjsToSave        = structNew();
    // The temp subject of the return msg
    var msgSubject              = '';
    // The temp action of the return msg
    var msgAction               = '';           
    // committed data struct
    var committed               = structNew();
    // msgSubject and msgAction return struct
    var committed.returnMsg     = structNew();
    // holds the model object properties
    var properties              = structNew();
    //current row username, if applicable
    var currentUserName         = '';

    // if entity required companyId relationship
    if( ListFindNoCase( this.typeNeedsCompId, shrtName) ){
        var companyObj = EntityLoadByPK( 'companyInfo', companyId );
    };          

    // If we are Adding Users (AU), create the entity and get bean metadata
    if( ListFindNoCase( 'AU,UU', TRIM( shrtName ), ',' , false ) ) {
        currentEntity = EntityNew( "CompanyUsers" );
        properties = getMetaData( currentEntity ).properties;
    }

    //toCommit Counter
    i=0;
//------------[START] Primary 'row' loop -------------
    for( row IN toCommit ){
        i++;

        //drop into row var
        row = toCommit[i];              

        // clear primaries--Future Use.
        structClear( entityObjsToSave );
        currentUserName = '';
        msgSubject      = '';
        msgAction       = '';

        //Update listOfKeys for this record
        listOfKeys  = StructKeyList(toCommit[i]);

        //assign username for frequent, future reference
        if( ListFindNoCase(listOfKeys, 'USERNAME' ) ){
            currentUserName = structFind( row, 'USERNAME' );
        }

        // If we are Adding Users (AU) or Updating Users (UU), create the entity and assign default msg values
        if(shrtName eq 'AU'){                   
            ORMEvictEntity("CompanyUsers");
            currentEntity   = EntityNew( "CompanyUsers" );
            msgSubject  = TRIM( currentUserName );
            msgAction       = ' - submitted successfully';
        }

        properties = getMetaData( currentEntity ).properties;
    //------------[START] FUTURE CONDITIONS -------------

    //.------------[END] FUTURE CONDITIONS -------------

        // Set companyId to entity
        if( ListFindNoCase( this.typeNeedsCompId, shrtName ) ){
            currentEntity.setCompanyId( companyObj );
        };
        try{

        //------------[START] Looping items in row -------------
            for( property IN properties ){
                currentField    = setFieldNameAndValue( property, row, listOfKeys );
                //if this field was not ruled out for some reason previously but caught locally
                if( currentField.fieldValue NEQ 'IGNORE' ){
                    // if the field name is listed in toCommitOwnFunction, split off for separate processing
                    if( ListFindNoCase( toCommitOwnFunction, TRIM( currentField.fieldName ), "," ) ){
                        // test toCommitOwnFunction field names
                        switch (currentField.fieldName){
                            case 'userGroups':
                                    if( isDefined( 'groupObj' ) ){
                                        ORMEvictEntity('groupObj');
                                    }
                                    if( isDefined( 'entity_groupObject' ) ){
                                        ORMEvictEntity("entity_groupObject");
                                    };
                                    groupObj            = EntityLoad( 'companyGroups', { groupName = #currentField.fieldValue# });
                                    entity_groupObject  = EntityNew('companyUsers_J_companyGroups');
                                    entity_groupObject.setUserId(currentEntity);
                                    entity_groupObject.setGroupId(groupObj);
                                    break;
                            default:
                                msgAction = '-Error.  Unexpected Field';
                        }
                    }
                    else{

                        if( LEN(TRIM(currentField.fieldValue))){
                            //Simple field type insertion
                            evaluate( "currentEntity." & "set#currentField.fieldName#( currentField.fieldValue )" );
                        };
                    };
                };
            };
        //.------------[END] Looping items in row -------------

            transaction {
                EntitySave(currentEntity);
                if( !isNull( entity_groupObject ) ){
                    EntitySave( entity_groupObject );
                };
                transactionCommit();
            };
            committed.returnMsg[i] = TRIM( msgSubject ) & TRIM( msgAction );
        }               
        catch(any e){
            committed.returnMsg[i] = TRIM( msgSubject ) & ' - Action Failed.  No additional information is available.<br/><br/>' & e;               }
    }
//.------------[END] Primary 'row' loop -------------
    return committed;
};

Моя остающаяся проблема - это groupObj, просто из-за моего отсутствия опыта ORM, я уверен.
У меня есть cfcs для CompanyUsers с выражением один-ко-многим, выраженным в companyUsers_J_companyGroups и CompanyGroupsс тем же (назад к companyUsers_J_companyGroups).companyUsers_J_companyGroups имеет много-к-одному указывал обратно на CompanyUsers и CompanyGroups -

    property name='userId'
            fieldtype='id,many-to-one'
            displayname='userId'
            cfc='companyUsers'
            fkcolumn='userId'
            hint='The user side of the relationship';
property name='groupId'
            fieldtype='id,many-to-one'
            displayname='groupId'
            cfc='companygroups'
            fkcolumn='groupId'
            hint='The group side of the user/group relationship';

Я продолжаю получать ошибки при обработке группы.

Answer 1

Основная проблема, с которой я столкнулся в этом решении, заключалась в том, что требования синтаксического анализатора CF (относительно: #, оценки и т. Д.) Казались нелогичными.Я не большой поклонник «оценки» для начала.Несмотря на это, следующее решает проблему.Выдающимся является поддержание реляционных сущностей, о которых будет сказано в отдельном посте.

        private function commitStruct( required any toCommit, required string toCommitOwnFunction, string shrtName, any companyId ){

        // ORM object to save.  Create for clearing at loop head
        var currentEntity= structNew();

        // committed data struct
        var committed   = structNew();

        // holds the model object properties
        var properties  = structNew();

        // Create default entity object and metadata
        currentEntity   = EntityNew( "CompanyUsers" );
        properties      = getMetaData( currentEntity ).properties;

        //toCommit Counter
        i = 0;

    //------------[START] Primary 'row' loop -------------
        for( row IN toCommit ){

            i++;

            //drop into row var
            row = toCommit[i];

            // Here we are Evicting the entity for reuse.
            ORMEvictEntity("CompanyUsers");

            //create the entity 
            currentEntity   = EntityNew( "CompanyUsers" );

            //getting the cfc column setup and properties
            properties      = getMetaData( currentEntity ).properties;

            try{
                //------------[START] Looping items in row -------------
                for( property IN properties ){
                    //assign the fieldname 
                    current.fieldName   = #property.Name#;
                    //assign the fieldvalue to appropriate var, current.fieldValue
                    current.fieldValue = structFind( row, current.fieldName );

                    // Simple field type insertion, meaning one-to-many, many-to-many, et al would need
                    // to be split off and handled differently.
                    evaluate( "currentEntity." & "set#currentField.fieldName#( currentField.fieldValue )" );

                };
                //.------------[END] Looping items in row -------------

                transaction {

                    // Save the entity
                    EntitySave(currentEntity);

                    transactionCommit();
                };
            }
            catch(any e){
                writeDump(e);
            }
        }
    //.------------[END] Primary 'row' loop -------------
    };

Большое спасибо @James A Mohler за все его советы.