entityinstallationaction.java

来自「CRM源码This file describes some issues tha」· Java 代码 · 共 1,805 行 · 第 1/5 页

        // check cached entity
        if( entity.getCache().booleanValue() ) {
            DEBUG( "       Entity " + entity.getName() + " is cached..." );

            Efield field1 = entity.getEfield( 0 );
            if( !field1.getPkey().booleanValue() ) {
                throw new GenericSystemException( "First field should be a public key. Entity " +
                                                  entity.getName() );
            }
        }
    }


    /**
     * Add common attributes into the Efield object using Entity object
     * @param entity Entity object
     * @param efield Efield object
     */
    private void driveEfieldAttributes( Entity entity, Efield efield ) {

        String efieldName = efield.getName();
        String entityName = entity.getName();

        // check is history
//        if( efieldName.equals( HistoryConstants.HISTORY_FIELD ) ) {
//            // set hasHistoryFields attribute for entity
//            entity.setHasHistoryFields( Boolean.TRUE );
//        }

        // build id attr
        String id = EntityHelper.getFieldId( entityName, efieldName );
        efield.setId( id );

        // build entityName attr
        efield.setEntityName( entityName );

        String eqlSrc = efield.getEqlSrc();
        if( !StringHelper.isEmpty( eqlSrc ) ) {
            //
            // field has 'eql-src' attribute
            //
            efield.setVirtual( Boolean.TRUE );
            efield.setUpdatable( Boolean.FALSE );
            efield.setEqlSrc( makeVariableSubstitution( entity, eqlSrc ) );

        } else if( efield.getRef() != null ) {
            //
            // field has Ref object
            //
            efield.setVirtual( Boolean.TRUE );
            efield.setUpdatable( Boolean.FALSE );

        } else {
            //
            // field exists in table !!!
            //
            boolean entityInitialized = entity.getInitialized().booleanValue();
            efield.setVirtual( Boolean.FALSE );

            if( !entityInitialized ) {

                // add column attributes (only for non reference fields) using meta data
                EntityFieldInfoVO dbInfo = getEntityFieldInfo( entity, efield );
                if( dbInfo == null ) {
                    throw new GenericSystemException( "Cannot find info for field '" +
                        efield.getId() + "'" );
                }

                // build 'sqltype' attr
                if( efield.getSqltype() == null ) {
                    efield.setSqltype( dbInfo.getSqlType() );
                }

                // build 'datasize' attr
                if( efield.getDatasize() == null ) {
                    efield.setDatasize( new Integer( dbInfo.getColumnSize() ) );
                }

                // build 'nullable' attribute
                if( efield.getNullable() == null ) {
                    efield.setNullable( new Boolean( dbInfo.isIsNullable() ) );
                }

                // set pkey for efield from DB
                EntityDdobjectInfoVO dbobjectInfo = getEntityDdobjectInfo( entity );
                int pkeySize = dbobjectInfo.getPkeySize();
                for( int i = 0; i < pkeySize; i++ ) {
                    String pkey = dbobjectInfo.getPkey( i );
                    if( efieldName.equalsIgnoreCase( pkey ) ) {
                        efield.setPkey( Boolean.TRUE );
                        entity.setPkeyfield(efieldName);
                        break;
                    }
                }
            }
        }

        // first check efields that don't have Ref
        // because method #updateRefEfieldAttributes will initialize some attrs later
        if( efield.getRef() == null ) {
            // check 'sqltype'
            if( efield.getSqltype() == null ) {
                // .. throw exception
                throw new GenericSystemException( "Please specify 'sqltype' for field '" +
                                                  efield.getId() + "'" );
            }

            // check 'datasize'
            if( efield.getDatasize() == null ) {
                // .. print warning
                WARN( "Datasize of field '" + efield.getId() + "' is empty!" );
            }
        }

        // build 'hasHistoryField' attribute
        if( efield.getControl() != null ) {
            if( efield.getControl().getType() == ControlSType.HISTORY_TYPE ) {
                entity.setHasHistoryFields( Boolean.TRUE );
                entity.setHistoryfield(efield.getName());
            }
        }

        // build 'nullable' attribute
        if( efield.getNullable() == null ) {
            // .. set to false if empty
            efield.setNullable( Boolean.TRUE );
        }

        // build 'eql-defsrc' attr
        String defEqlSrc = efield.getEqlDefsrc();
        if( !StringHelper.isEmpty( defEqlSrc ) ) {
            efield.setEqlDefsrc( makeVariableSubstitution( entity, defEqlSrc ) );
        }

        // build 'datatype' attr
        if( efield.getDatatype() == null ) {
            if( efield.getSqltype() != null ) {
                efield.setDatatype( DataSType.valueOf( efield.getSqltype().toString() ) );
            }
        }

        // set 'required' to ~'nullable' if not defined
        if( efield.getRequired() == null ) {
            efield.setRequired( new Boolean( !efield.getNullable().booleanValue() ) );
        }

        // build 'pkey' attribute
        if( efield.getPkey() == null ) {
            efield.setPkey( Boolean.FALSE );
        }

        // check is field name unique
        if( entity.getObject( efieldName ) != null ) {
            throw new GenericSystemException( "Duplicate name '" + efieldName +
                                              "' in entity '" + entityName + "'" );
        }

        // add in name list
        entity.putObject( efieldName, efield );
    }


    /**
     * Update (add) Efield object attributes using Ref object
     * @param entity Entity object
     * @param efield Efield object
     */
    private void updateRefEfieldAttributes( Entity entity, Efield efield ) {

        Ref ref = efield.getRef();
        if( ref == null ) {
            return;
        }

        String e1 = entity.getName();
        String f1 = efield.getName();
        DEBUG( "*** Update Ref. Entity " + e1 + ". Field " + f1 );

        //
        // update Ref object
        //
        Entity entity2 = getEntityViewConfig( ref.getEntity() );
        String f2 = ref.getEfield();
        Efield field2 = EntityHelper.getEfield( f2, entity2 );

        // check ref field
        if( field2.getVirtual().booleanValue() ) {
            throw new GenericSystemException( "Ref field '" + f2 + "' must be none virtual. Entity '" +
                                              e1 + "'. Field '" + f1 + "'" );
        }

        // copy undefined attributes from reference field
        xmlBind.copyUndefinedAttributes( field2, efield, Efield.class );

        // copy Listref object
        if( field2.getListref() != null ) {
            efield.setListref( ( Listref ) xmlBind.clone( field2.getListref(), Listref.class ) );
        }
    }


    /**
     * Update (add) Efield object attributes using Listref object
     * @param entity Entity object
     * @param efield Efield object
     */
    private void updateLrefEfieldAttributes( Entity entity, Efield efield ) {

        if( efield.getRef() != null ) {
            return;
        }

        Listref lref = efield.getListref();
        if( lref == null ) {
            return;
        }

        //
        // update Listref object
        //
        String e1 = entity.getName();
        String db1 = entity.getDbobject();
        String f1 = efield.getName();

        String e2 = lref.getEntity();
        Entity entity2 = getEntityViewConfig( e2 );
        String db2 = entity2.getDbobject();
        String f2 = lref.getEfield();
        if( f2 == null ) {
            f2 = entity2.getListfield();
        }
        if( f2 == null ) {
            throw new GenericSystemException( "Cannot find list field. Entity '" +
                                              e1 + "'. Field '" + f1 + "'" );
        }

        // check listref field
        Efield field2 = EntityHelper.getEfield( f2, entity2 );
        if( field2.getVirtual().booleanValue() ) {
            throw new GenericSystemException( "List field '" + f2 + "' should be none virtual. Entity '" +
                                              e1 + "'. Field '" + f1 + "'" );
        }

        // set 'efield' attr
        lref.setEfield( f2 );

        // set Dataschema object
        String refName = lref.getRefname();
        Dataschema ds = getDataschema( db1, f1, db2, refName );
        if( ds == null ) {
            throw new GenericSystemException( "Cannot find dataschema for entities '" + e1 +
                                              "' and '" + e2 + "' with name '" + refName + "'" );
        }
        lref.setDataschema( ds );

        // set 'refname' attr
        if( refName == null ) {
            lref.setRefname( ds.getName() );
        }
    }


    /**
     * Update (add) Dataset object attributes
     * @param entity Entity object
     * @param dataset Dataset object
     */
    private void updateDatasetAttributes( Entity entity, Dataset dataset ) {

        String entityName = entity.getName();
        String dbobject = entity.getDbobject();
        String datasetName = dataset.getName();
        String refEntityName = dataset.getEntity();
        String refName = dataset.getRefname();
        Entity refEntity = getEntityViewConfig( refEntityName );
        String refDbobject = refEntity.getDbobject();

        // build id attr
        String id = EntityHelper.getDatasetId( entity, dataset );
        dataset.setId( id );

        DEBUG( "   update dataset '" + id + "'" );

        // set 'required' to false if not defined
        if( dataset.getRequired() == null ) {
            dataset.setRequired( Boolean.FALSE );
        }

        // set parent entity name
        dataset.setEntityName( entityName );

        // find suited dataschema
        Dataschema ds = null;

        if( !StringHelper.isEmpty( refName ) ) {
            // get dataschema by the 'refname' attr
            ds = getDataschema( dbobject, null, refDbobject, refName );
            if( ds == null ) {
                throw new GenericSystemException( "Cannot find dataschema between '" +
                                                  dbobject + "' and '" + refDbobject +
                                                  "' tables by the name '" + refName + "'" );
            }

        } else {
            // try to find suited chain
            ChainTable chtab = EntityHelper.getChainTable( refEntityName, entity );
            if( chtab == null ) {
                throw new GenericSystemException( "Cannot find chain between '" +
                                                  refEntityName + "' and '" +
                                                  entityName + "' entites" );
            }

            ds = chtab.getDataschema();
        }

        // set Dataschema element
        dataset.setDataschema( ds );

        // check is dataset name unique
        if( entity.getObject( datasetName ) != null ) {
            throw new GenericSystemException( "Duplicate name '" + datasetName +
                                              "' in entity '" + entityName + "'" );
        }

        // add in name list
        entity.putObject( datasetName, dataset );

        // set EQL query
        Entity datasetEntity = getEntityViewConfig( dataset.getEntity() );
        StringBuffer eql = new StringBuffer();
        eql.append( "SELECT " );
        eql.append( datasetEntity.getName() );
        eql.append( ".* WHERE " );

        String[] datasetKeys = ds.getTable( 1 ).getKey();
        for( int i = 0; i < datasetKeys.length; i++ ) {
            if( i > 0 ) {
                eql.append( " AND " );

            }
            Efield datasetEfield = EntityHelper.getEfieldBySrc( datasetKeys[i], datasetEntity );
            eql.append( datasetEfield.getId() );
            eql.append( " = ?" );
        }

        dataset.setEql( eql.toString() );

        // create fkey for this dataschema
        // find exists Fkey
        Fkeys fkeys = null;
        int size = entity.getFkeysCount();
        for( int i = 0; i < size; i++ ) {
            Fkeys _fkeys = entity.getFkeys( i );
            if( refDbobject.equalsIgnoreCase( _fkeys.getFkTable() ) ||
                refEntityName.equalsIgnoreCase( _fkeys.getFkEntity() ) ) {
                // find!
                fkeys = _fkeys;
                break;
            }
        }