import org.pentaho.di.core.exception.KettleTransException; //导入依赖的package包/类
private void isFileOpenedInFolder( String path ) throws KettleException {
  List<TransMeta> openedTransFiles = getSpoon().delegates.trans.getTransformationList();
  for ( TransMeta t : openedTransFiles ) {
    if ( t.getRepositoryDirectory().getPath() != null
      && ( t.getRepositoryDirectory().getPath() + "/" ).startsWith( path + "/" ) ) {
      throw new KettleTransException();
    }
  }
  List<JobMeta> openedJobFiles = getSpoon().delegates.jobs.getJobList();
  for ( JobMeta j : openedJobFiles ) {
    if ( j.getRepositoryDirectory().getPath() != null
      && ( j.getRepositoryDirectory().getPath() + "/" ).startsWith( path + "/" ) ) {
      throw new KettleJobException();
    }
  }
}
 

import org.pentaho.di.core.exception.KettleTransException; //导入依赖的package包/类
@POST
@Path( "/rename/{id}/{path}/{newName}/{type}/{oldName}" )
public Response rename( @PathParam( "id" ) String id, @PathParam( "path" ) String path,
                        @PathParam( "newName" ) String newName, @PathParam( "type" ) String type,
                        @PathParam( "oldName" ) String oldName ) {

  try {
    ObjectId objectId = repositoryBrowserController.rename( id, path, newName, type, oldName );
    if ( objectId != null ) {
      return Response.ok( objectId ).build();
    }
  } catch ( KettleObjectExistsException koee ) {
    return Response.status( Response.Status.CONFLICT ).build();
  } catch ( KettleTransException | KettleJobException ktje ) {
    return Response.status( Response.Status.NOT_ACCEPTABLE ).build();
  } catch ( KettleException ke ) {
    return Response.notModified().build();
  }

  return Response.notModified().build();
}
 

import org.pentaho.di.core.exception.KettleTransException; //导入依赖的package包/类
public boolean remove( String id, String name, String path, String type ) throws KettleException {
  try {
    switch ( type ) {
      case "job":
        if ( isJobOpened( id, path, name ) ) {
          throw new KettleJobException();
        }
        removeRecent( id, type );
        getRepository().deleteJob( () -> id );
        break;
      case "transformation":
        if ( isTransOpened( id, path, name ) ) {
          throw new KettleTransException();
        }
        removeRecent( id, type );
        getRepository().deleteTransformation( () -> id );
        break;
      case "folder":
        isFileOpenedInFolder( path );
        removeRecentsUsingPath( path );
        RepositoryDirectoryInterface repositoryDirectoryInterface = getRepository().findDirectory( path );
        if ( getRepository() instanceof RepositoryExtended ) {
          ( (RepositoryExtended) getRepository() ).deleteRepositoryDirectory( repositoryDirectoryInterface, true );
        } else {
          getRepository().deleteRepositoryDirectory( repositoryDirectoryInterface );
        }
        break;
    }
    return true;
  } catch ( KettleTransException | KettleJobException ke  ) {
    throw ke;
  } catch ( Exception e ) {
    return false;
  }
}
 

import org.pentaho.di.core.exception.KettleTransException; //导入依赖的package包/类
/**
 * Begin processing. Also handle logging operations related to the start of the transformation
 *
 * @throws KettleTransException
 *           the kettle trans exception
 */
public void beginProcessing() throws KettleTransException {
  TransLogTable transLogTable = transMeta.getTransLogTable();
  int intervalInSeconds = Const.toInt( environmentSubstitute( transLogTable.getLogInterval() ), -1 );

  try {
    String logTable = transLogTable.getActualTableName();

    SimpleDateFormat df = new SimpleDateFormat( REPLAY_DATE_FORMAT );
    log.logDetailed( BaseMessages.getString( PKG, "Trans.Log.TransformationCanBeReplayed" ) + df.format(
        currentDate ) );

    try {
      if ( transLogTableDatabaseConnection != null && !Utils.isEmpty( logTable ) && !Utils.isEmpty( transMeta
          .getName() ) ) {
        transLogTableDatabaseConnection.writeLogRecord( transLogTable, LogStatus.START, this, null );

        // Pass in a commit to release transaction locks and to allow a user to actually see the log record.
        //
        if ( !transLogTableDatabaseConnection.isAutoCommit() ) {
          transLogTableDatabaseConnection.commitLog( true, transLogTable );
        }

        // If we need to do periodic logging, make sure to install a timer for this...
        //
        if ( intervalInSeconds > 0 ) {
          final Timer timer = new Timer( getName() + " - interval logging timer" );
          TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
              try {
                endProcessing();
              } catch ( Exception e ) {
                log.logError( BaseMessages.getString( PKG, "Trans.Exception.UnableToPerformIntervalLogging" ), e );
                // Also stop the show...
                //
                errors.incrementAndGet();
                stopAll();
              }
            }
          };
          timer.schedule( timerTask, intervalInSeconds * 1000, intervalInSeconds * 1000 );

          addTransListener( new TransAdapter() {
            @Override
            public void transFinished( Trans trans ) {
              timer.cancel();
            }
          } );
        }

        // Add a listener to make sure that the last record is also written when transformation finishes...
        //
        addTransListener( new TransAdapter() {
 

import org.pentaho.di.core.exception.KettleTransException; //导入依赖的package包/类
public ObjectId rename( String id, String path, String newName, String type, String oldName ) throws KettleException {
  RepositoryDirectoryInterface repositoryDirectoryInterface = getRepository().findDirectory( path );
  ObjectId objectId = null;
  switch ( type ) {
    case "job":
      if ( getRepository().exists( newName, repositoryDirectoryInterface, RepositoryObjectType.JOB ) ) {
        throw new KettleObjectExistsException();
      }
      if ( isJobOpened( id, path, oldName ) ) {
        throw new KettleJobException();
      }
      renameRecent( id, type, newName );
      objectId = getRepository().renameJob( () -> id, repositoryDirectoryInterface, newName );
      break;
    case "transformation":
      if ( getRepository().exists( newName, repositoryDirectoryInterface, RepositoryObjectType.TRANSFORMATION ) ) {
        throw new KettleObjectExistsException();
      }
      if ( isTransOpened( id, path, oldName ) ) {
        throw new KettleTransException();
      }
      renameRecent( id, type, newName );
      objectId = getRepository().renameTransformation( () -> id, repositoryDirectoryInterface, newName );
      break;
    case "folder":
      isFileOpenedInFolder( path );
      RepositoryDirectoryInterface parent = getRepository().findDirectory( path ).getParent();
      if ( parent == null ) {
        parent = getRepository().findDirectory( path );
      }
      RepositoryDirectoryInterface child = parent.findChild( newName );
      if ( child != null ) {
        throw new KettleObjectExistsException();
      }
      if ( getRepository() instanceof RepositoryExtended ) {
        objectId =
          ( (RepositoryExtended) getRepository() ).renameRepositoryDirectory( () -> id, null, newName, true );
      } else {
        objectId = getRepository().renameRepositoryDirectory( () -> id, null, newName );
      }
      break;
  }
  return objectId;
}