getrecordsejb.java

CRM源码This file describes some issues that should be implemented in future and how it should be imple

        //

        // 1. add ext response attributes
        {
            out.println( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" );
            out.print( "<ext-ress " );
            out.print( "formid=\"" + formName + "\" " );
            out.println( ">" );
        }

        // 2. add ext request object
        if(extReqs.getGetextrequest()) {
            XMLHelper.writeObject( extReqs, out, true );
        }

        // 3. Call recursively SUB extended process.
        int pkeys = extReqs.getExtPkeyCount();
        Efield[] pkeyFields = new Efield[pkeys];
        CompoundKey compoundKey = new CompoundKey();
        for( int i = 0; i < pkeys; i++ ) {
            ExtPkey extPkey = extReqs.getExtPkey( i );
            pkeyFields[i] = EntityHelper.getEfield( extPkey.getName(), entity );
            compoundKey.addKey( extPkey.getValue() );
        }
        extSubProcess( out, form, entity, pkeyFields, compoundKey, sc );

        // Ok.
        out.println( "</ext-ress>" );

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "...ext getRecords complete time(ms)=" + ( System.currentTimeMillis() - time ) );
        }
    }

    // ----------------------------------------------------- private methods

    //
    // Execute get records procedure
    //
    private GetRecordsRes process( Entity baseEntity,
                                   Efield[] pkeyFields,
                                   CompoundKey[] compoundPkeys,
                                   Properties prop,
                                   LogonSession sc )
        throws EQLException {

        // get Reqs object
        Reqs reqs = buildReqs( baseEntity, pkeyFields, compoundPkeys, prop );

        // do process
        return process( reqs, sc );
    }

    //
    // Execute get records procedure
    //
    private void process( PrintWriter out,
                          Entity baseEntity,
                          Efield[] pkeyFields,
                          CompoundKey[] compoundPkeys,
                          Properties prop,
                          LogonSession sc,
                          boolean clearXml )
        throws EQLException {

        // get Reqs object
        Reqs reqs = buildReqs( baseEntity, pkeyFields, compoundPkeys, prop );

        // do process
        process( reqs, out, sc, clearXml );
    }

    //
    // Execute get records procedure
    //
    private void process( Reqs reqs,
                          PrintWriter out,
                          LogonSession sc,
                          boolean clearXml )
        throws EQLException {

        long time = System.currentTimeMillis();

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "Start process:" );
            printMemoryUsage();

            DEBUG( "GetRecords request:" );
            DEBUG( "-------------------" );
            DEBUG( new String( XMLHelper.writeObject( reqs ) ) );
            DEBUG( "-------------------" );
        }

        try {
            // Get request parameters.
            int page = reqs.getPage();
            int pageSize = reqs.getPagesize();
            boolean doHeader = reqs.getDoheader();
            boolean getRequest = reqs.getGetrequest();

            // Call action and redirect output to special writer.
            if( getLogger().isDebugEnabled() ) {
                DEBUG( "Try to get records: " );
                printMemoryUsage();
            }

            // create context
            ActionContext ctx = new ActionContext( sc,
                getEntityViewConfigManager(),
                getFocusConfigManager(),
                getCustomConfigManager(),
                getEQLManager(),
                getUserPropertyManager() );

            // call action
            CharArrayWriter recordsCaw = new CharArrayWriter();
            GRAction gra = AbstractGRAction.process( ctx, reqs, recordsCaw );

            if( getLogger().isDebugEnabled() ) {
                DEBUG( "Got records: " );
                printMemoryUsage();
            }

            //
            // Do writing.
            //

            // 1. add response attributes
            {
                if( !clearXml ) {
                    out.println( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" );
                }
                out.print( "<ress " );
                out.print( "count=\"" + gra.getCount() + "\" " );
                out.print( "rows=\"" + gra.getRows() + "\" " );
                out.print( "page=\"" + page + "\" " );
                out.print( "pagesize=\"" + pageSize + "\" " );
                out.print( "next=\"" + gra.hasMore() + "\" " );
                if( page > 0 ) {
                    out.print( "prev=\"true\" " );
                } else {
                    out.print( "prev=\"false\" " );
                }
                out.print( "new=\"" + ( gra instanceof NewGRAction ) + "\" " );
                out.println( ">" );
            }

            // 2. add request object
            if( getRequest ) {
                XMLHelper.writeObject( reqs, out, true );
            }

            // 3. add header object
            if( doHeader ) {
                ResHeader resHeader = gra.getHeader();
                XMLHelper.writeObject( resHeader, out, true );
            }

            // 4. add records
            {
                if( getLogger().isDebugEnabled() ) {
                    DEBUG( "Try to add records: " );
                    printMemoryUsage();
                }

                out.println( "<res>" );
                recordsCaw.writeTo( out );
                recordsCaw.close();
                out.println( "</res>" );
            }

            // 5. ok
            {
                if( getLogger().isDebugEnabled() ) {
                    DEBUG( "Ok: " );
                    printMemoryUsage();
                }

                out.println( "</ress>" );
            }

        } catch( EQLException ex ) {
            throw ex;

        } catch( OutOfMemoryError ex ) {
            ERROR( ex );
            throw new QueryTooBigException();

        } catch( Throwable t ) {
            ErrorHelper.throwSystemException( t, this );
        }

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "...getRecords complete time(ms)=" +
                   ( System.currentTimeMillis() - time ) );
        }
    }

    //
    // Execute get records SUB extended procedure
    //
    private void extSubProcess( PrintWriter out,
                                Form baseForm,
                                Entity baseEntity,
                                Efield[] pkeyFields,
                                CompoundKey compoundPkey,
                                LogonSession sc )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "Call ext sub process:" );
            DEBUG( "		entity: " + baseEntity.getName() );
            DEBUG( "		form: " + baseForm.getName() );
            DEBUG( "		pkey[0]: " + pkeyFields[0].getId() );
            DEBUG( "		key[0]: " + compoundPkey.getKey( 0 ) );
        }

        int ext_count = baseForm.getExternalSetCount();
        for( int i = 0; i < ext_count; i++ ) {
            // get ExternalSet object
            ExternalSet extSet = baseForm.getExternalSet( i );
            String formName = extSet.getName();

            if( getLogger().isDebugEnabled() ) {
                DEBUG( "Found externaset: " + formName );
            }

            // get external Form
            Form extForm = getFocusConfigManager().getForm( formName );
            if( extForm == null ) {
                throw new NullPointerException( "Cannot find external form '" + formName + "'." );
            }

            // get external Entity
            String extEntityName = extForm.getEntity();
            Entity extEntity = getEntityViewConfigManager().getEntityViewConfig( extEntityName );

            // add form reference in property
            Properties prop = new Properties();
            prop.setProperty( GRAction.FORM_ID_PARAM, formName );

            // call GetRecords process for external entity
            GetRecordsRes extGRRes = process( extEntity,
                                              pkeyFields,
                                              new CompoundKey[] {compoundPkey}
                                              ,
                                              prop,
                                              sc );

            // write response
            XMLHelper.writeObject( extGRRes.getRess(), out, true );
        }
    }

    //
    // Build Reqs object
    //
    private Reqs buildReqs( Entity baseEntity,
                            Efield[] pkeyFields,
                            CompoundKey[] compoundPkeys,
                            Properties prop )
        throws EQLException {

        String entityName = baseEntity.getName();

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "Get records for entity '" + entityName + "'." );
            DEBUG( "  records: " + ( compoundPkeys == null ? 0 : compoundPkeys.length ) );
            if( compoundPkeys != null ) {
                DEBUG( "  record[0]: " + compoundPkeys[0] );
            }
        }

        // Reqs object
        Reqs reqs = new Reqs();
        if( prop != null && prop.getProperty( GRAction.IGNORE_SEND_ON_REQ_PARAM ) != null ) {
            reqs.setIgnoreSendOnRequest( Boolean.TRUE );
        } else {
            reqs.setIgnoreSendOnRequest( Boolean.FALSE );
        }

        // Req object
        Req req = new Req();
        reqs.setReq( req );

        // ReqEntity object
        ReqEntity reqEntity = new ReqEntity();
        reqEntity.setName( entityName );
        req.setReqEntity( reqEntity );
        if( prop != null ) {
            reqEntity.setFormid( prop.getProperty( GRAction.FORM_ID_PARAM ) );
        }

        if( compoundPkeys != null ) {

            // create base ReqFilters object
            ReqFilters reqFilters = new ReqFilters();
            reqFilters.setType( ConditionSType.OR );
            reqs.setReqFilters( reqFilters );

            // add filters
            for( int i = 0; i < compoundPkeys.length; i++ ) {
                CompoundKey compoundPkey = compoundPkeys[i];

                // concrete ReqFilters object for one record
                ReqFilters _reqFilters = new ReqFilters();
                _reqFilters.setType( ConditionSType.AND );
                ReqFiltersTypeItem _reqFilterItem = new ReqFiltersTypeItem();
                _reqFilterItem.setReqFilters( _reqFilters );
                reqFilters.addReqFiltersTypeItem( _reqFilterItem );

                for( int j = 0; j < pkeyFields.length; j++ ) {
                    Efield field = pkeyFields[j];
                    Object key = compoundPkey.getKey( j );
                    if( key == null ) {
                        key = StringHelper.NULL_VALUE;
                    }

                    // create ReqFilter object for concrete filter
                    ReqFilter __reqFilter = new ReqFilter();
                    __reqFilter.addReqFilterValue( key.toString() );
                    __reqFilter.setEntity( field.getEntityName() );
                    __reqFilter.setName( field.getName() );

                    ReqFiltersTypeItem __reqFilterItem = new ReqFiltersTypeItem();
                    __reqFilterItem.setReqFilter( __reqFilter );
                    _reqFilters.addReqFiltersTypeItem( __reqFilterItem );
                }
            }
        }

        return reqs;
    }

    // Debug.
    private void printMemoryUsage() {
        if( getLogger().isDebugEnabled() ) {
            DEBUG( "=======> free memory: " + Runtime.getRuntime().freeMemory() +
                   ", total memory: " + Runtime.getRuntime().totalMemory() +
                   "<========" );
        }
    }
}