eqlmanagerejb.java

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

            }

            // Update datasets.
            int size = resRecord.getDResSize();
            for( int j = 0; j < size; j++ ) {
                DEBUG( "......try update dataset: " + j );
                __update( eqlSession, resRecord.getDRes( j ), null );
            }

            // Run post-update scripts.
            if( hasScripts ) {
                Afterupdate[] afterUpdates = entity.getScripts().getAfterupdate();
                if( afterUpdates != null ) {
                    for( int j = 0; j < afterUpdates.length; j++ ) {
                        doEntityUpdate( eqlSession, res, resRecord, afterUpdates[j] );
                    }
                }
            }

            // Reset record status.
            resRecord.resetStatus();

        } catch( EQLSystemException eqlex ) {
            throwEQLSystemException( eqlex, entity );
        }

        // Ok. Continue update(s).
        return CONTINUE;

    }

    //
    // Does the record delete.
    //
    private int doDelete( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord )
        throws EQLException {

        int status = CONTINUE;

        // Get base entity.
        Entity entity = res.getEntity();

        try {

            // Run pre-delete scripts.
            boolean hasScripts = ( entity.getScripts() != null );
            if( hasScripts ) {
                Beforedelete[] beforeDeletes = entity.getScripts().getBeforedelete();
                if( beforeDeletes != null ) {
                    for( int j = 0; j < beforeDeletes.length; j++ ) {
                        status = doEntityUpdate( eqlSession, res, resRecord, beforeDeletes[j] );
                        if( status == EntityUpdate.SKIP_ALL ) {
                            return SKIP;
                        }
                        if( status == EntityUpdate.SKIP_RECORD ) {
                            return CONTINUE;
                        }
                    }
                }
            }

            // Remove referenced (fk) records.
            Fkeys[] fkeyss = entity.getFkeys();
            if( fkeyss != null ) {
                for( int j = 0; j < fkeyss.length; j++ ) {

                    Fkeys fkeys = fkeyss[j];
                    String fkEntityName = fkeys.getFkEntity();
                    String fkColumnName = fkeys.getFkColumn();
                    String pkColumnName = fkeys.getPkColumn();
                    boolean cascadeDelete = fkeys.getCascadeDelete().booleanValue();

                    // Get primary key field name and value.
                    Efield pkField = EntityHelper.getEfieldBySrc( pkColumnName, entity );
                    EQLResCell resCell = resRecord.getResCell( new EQLReqField( entity, pkField ) );
                    if( resCell == null ) {
                        throw new GenericSystemException( "Primary key field '" + pkField.getId() + "' value not found" );
                    }
                    EQLObject pkValue = resCell.getEQLObject();

                    if( fkEntityName != null ) {

                        // Remove from referenced entity.
                        Entity fkEntity = getEntityViewConfigManager().getEntityViewConfig( fkEntityName );
                        Efield fkField = EntityHelper.getEfieldBySrc( fkColumnName, fkEntity );
                        doDeleteFkRecords( eqlSession, fkEntity, fkField, pkValue, cascadeDelete );

                    } else {

                        // Remove from referenced table.
                        /** @todo Implement or remove it. */

                    }

                }
            }

            // Delete.
            Delete delete;

            // Run custom delete script (if any).
            if( hasScripts && ( delete = entity.getScripts().getDelete() ) != null ) {
                status = doEntityUpdate( eqlSession, res, resRecord, delete );
            }

            if( status == EntityUpdate.CONTINUE ) {
                // Call EQLAgent.
                EQLAgent agent = EQLAgentFactory.getInstance().getEQLAgent( res );
                agent.doDelete( eqlSession, res, resRecord );
            }

            // Remove record from result set.
            res.removeRecord( resRecord );

            // Run post-delete scripts.
            if( hasScripts ) {
                Afterdelete[] afterDeletes = entity.getScripts().getAfterdelete();
                if( afterDeletes != null ) {
                    for( int j = 0; j < afterDeletes.length; j++ ) {
                        doEntityUpdate( eqlSession, res, resRecord, afterDeletes[j] );
                    }
                }
            }

        } catch( EQLSystemException eqlex ) {
            throwEQLSystemException( eqlex, entity );
        }

        // Ok.
        return( status == EntityUpdate.SKIP_ALL ? SKIP : CONTINUE );

    }

    //
    // Do EQL delete fk entity
    //
    private void doDeleteFkRecords( EQLSession eqlSession,
                                    Entity fkEntity,
                                    Efield fkField,
                                    EQLObject pkValue,
                                    boolean cascadeDelete )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "   remove from fk entity:" );
            DEBUG( "     fk entity: '" + fkEntity.getName() + "'" );
            DEBUG( "     fk field: '" + fkField.getName() + "'" );
            DEBUG( "     pk value: '" + pkValue + "'" );
        }

        StringBuffer fkEqlQuery = new StringBuffer( "SELECT " );
        fkEqlQuery.append( fkEntity.getName() );
        fkEqlQuery.append( ".* WHERE " );
        fkEqlQuery.append( fkEntity.getName() ).append( "." ).append( fkField.getName() );
        fkEqlQuery.append( " = ?" );

        EQLIntPreparedStatement fkEqlPS = new EQLIntPreparedStatement();
        fkEqlPS.setObject( 1, pkValue );

        // get all fk records (ignore datasets)
        EQLReqMetaData meta = new EQLReqMetaData();
        meta.setIgnoreAllDatasets( true );
        EQLERes fkRes = ( EQLERes ) doSelect( eqlSession, fkEqlQuery.toString(), fkEqlPS, meta );
        if( fkRes.size() == 0 ) {
            // nothing do delete
            return;
        }

        if( cascadeDelete ) {
            // delete all fk records
            fkRes.markAllAsDelete();
            __update( eqlSession, fkRes, null );

        } else {
            // throw exception
            throw new EQLRemoveException( fkEntity, fkField, pkValue );
        }
    }

    // ========================================================= Special methods

    //
    // Get EQL session object
    //
    private EQLSession getEQLSession( LogonSession ls ) {
        // build EQL session
        EQLSession eqlSession = new EQLSession();
        eqlSession.setLogonSession( ls );
        return eqlSession;
    }

    //
    // Do EQL entity afternew
    //
    private void doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Afternew afternew )
        throws EQLException {

        EntityUpdate eu = getEntityUpdate( eqlSession, afternew.getName(), res, resRecord );
        eu.afterNew();
    }

    //
    // Do EQL entity update
    //
    private int doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Beforeupdate update )
        throws EQLException {

        EntityUpdate eu = getEntityUpdate( eqlSession, update.getName(), res, resRecord );
        return eu.beforeUpdate();
    }

    //
    // Do EQL entity update
    //
    private void doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Afterupdate update )
        throws EQLException {

        EntityUpdate eu = getEntityUpdate( eqlSession, update.getName(), res, resRecord );

        if( update.getAsync().booleanValue() ) {
            // do it async
            asyncClient.sendUpdateMessage( eu );
        } else {
            // do it sync
            eu.afterUpdate();
        }
    }

    //
    // Do EQL entity update
    //
    private int doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Update update )
        throws EQLException {

        EntityUpdate eu = getEntityUpdate( eqlSession, update.getName(), res, resRecord );
        return eu.update();
    }

    //
    // Do EQL entity update
    //
    private int doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Beforedelete update )
        throws EQLException {
        EntityUpdate eu = getEntityUpdate( eqlSession, update.getName(), res, resRecord );
        return eu.beforeDelete();
    }

    //
    // Do EQL entity update
    //
    private int doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Delete update )
        throws EQLException {

        EntityUpdate eu = getEntityUpdate( eqlSession, update.getName(), res, resRecord );
        return eu.delete();
    }

    //
    // Do EQL entity update
    //
    private void doEntityUpdate( EQLSession eqlSession, EQLERes res, EQLResRecord resRecord, Afterdelete update )
        throws EQLException {

        EntityUpdate eu = getEntityUpdate( eqlSession, update.getName(), res, resRecord );

        if( update.getAsync().booleanValue() ) {
            // do it async
            asyncClient.sendDeleteMessage( eu );
        } else {
            // do it sync
            eu.afterDelete();
        }
    }

    //
    // Get EQL entity update
    //
    private EntityUpdate getEntityUpdate( EQLSession eqlSession,
                                          String name,
                                          EQLERes res,
                                          EQLResRecord resRecord ) {

        EntityUpdateObject euo = new EntityUpdateObject( eqlSession, res, resRecord );

        return EntityUpdateFactory.getEntityUpdate( name, euo );
    }

    //
    // Get Lock manager local interface
    //
    private LockManagerLocal getLockManagerLocal() {
        return( LockManagerLocal ) getLocalObject( JNDINames.LockManager, LockManagerLocalHome.class );
    }

    //
    // Get history local interface
    //
    private HistoryLocal getHistoryLocalLocal() {
        return( HistoryLocal ) getLocalObject( JNDINames.History, HistoryLocalHome.class );
    }

    private void throwEQLSystemException( EQLSystemException eqlex, Entity entity ) {

        // Get EQL exception cause.
        Throwable t = eqlex.returnCause();

        // Exception type switch.
        if( t instanceof SQLDuplicateKeyException ) {
            String message =
                "Can't update entity '" + entity.getName() + "': record with the same primary key already exists.";
            throw new EQLDuplicateKeyException( message, t);

        } else if( t instanceof SQLIndexConflictException ) {
            String message =
                "Can't update entity '" + entity.getName() + "': record with the same unique index value already exists.";
            throw new EQLIndexConflictException( message, t);

        } else if( t instanceof SQLDeleteConflictException ) {
            String message =
                "Can't delete from entity '" + entity.getName() + "': record is referenced by another entity.";
            throw new EQLDeleteConflictException( message, t);

        } else if( t instanceof SQLDeadlockException ) {
            String message =
                "Can't modify entity '" + entity.getName() + "': database deadlock is occured.";
            throw new EQLDeadlockException( message, t);
        }

        // No special option - throw the original exception.
        throw eqlex;

    }

    // ============================================================= Inner class

    /**
     * Inner class to make any async action.
     *
     * @author [ALB] Baranov Andrey
     * @version $Revision: 1.1.1.1 $ $Date: 2005/09/12 15:30:23 $
     */

    private static class AsyncClient
        extends JMSClient {

        /**
         * Constructor
         */
        public AsyncClient() {
            super( JNDINames.JmsConnectionFactory, JNDINames.JmsAsyncQueue );
        }

        /**
         * Send async update message to message driven bean
         * @param obj ASyncObject object
         */
        public void sendUpdateMessage( ASyncObject obj ) {
            sendMessage( obj, EntityUpdate.UPDATE_REQUEST_FLAG );
        }

        /**
         * Send async delete message to message driven bean
         * @param obj ASyncObject object
         */
        public void sendDeleteMessage( ASyncObject obj ) {
            sendMessage( obj, EntityUpdate.DELETE_REQUEST_FLAG );
        }

        /**
         * Send message to message driven bean
         * @param obj ASyncObject object
         * @param request param for process method ASyncObject interface
         */
        private void sendMessage( ASyncObject obj, ASyncRequest request ) {

            HashMap map = new HashMap();
            map.put( AsyncMDB.OBJECT_PARAM, obj );
            if( request != null ) {
                map.put( AsyncMDB.REQUEST_PARAM, request );
            }

            send( map );
        }
    }

}