/*
* soapUI, copyright (C) 2004-2011 eviware.com
*
* soapUI is free software; you can redistribute it and/or modify it under the
* terms of version 2.1 of the GNU Lesser General Public License as published by
* the Free Software Foundation.
*
* soapUI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
* even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details at gnu.org.
*/
package com.eviware.soapui.impl;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.swing.ImageIcon;
import org.apache.log4j.Logger;
import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlOptions;
import com.eviware.soapui.SoapUI;
import com.eviware.soapui.config.SoapuiWorkspaceDocumentConfig;
import com.eviware.soapui.config.WorkspaceProjectConfig;
import com.eviware.soapui.config.WorkspaceProjectConfig.Status;
import com.eviware.soapui.config.WorkspaceProjectConfig.Type;
import com.eviware.soapui.impl.settings.XmlBeansSettingsImpl;
import com.eviware.soapui.impl.wsdl.WsdlProject;
import com.eviware.soapui.impl.wsdl.WsdlProjectFactory;
import com.eviware.soapui.impl.wsdl.support.PathUtils;
import com.eviware.soapui.model.ModelItem;
import com.eviware.soapui.model.project.Project;
import com.eviware.soapui.model.project.ProjectFactoryRegistry;
import com.eviware.soapui.model.settings.Settings;
import com.eviware.soapui.model.support.AbstractModelItem;
import com.eviware.soapui.model.workspace.Workspace;
import com.eviware.soapui.model.workspace.WorkspaceListener;
import com.eviware.soapui.settings.UISettings;
import com.eviware.soapui.support.MessageSupport;
import com.eviware.soapui.support.SoapUIException;
import com.eviware.soapui.support.StringUtils;
import com.eviware.soapui.support.UISupport;
import com.eviware.soapui.support.resolver.ResolveDialog;
import com.eviware.soapui.support.types.StringToStringMap;
/**
* Default Workspace implementation
*
* @author Ole.Matzura
*/
public class WorkspaceImpl extends AbstractModelItem implements Workspace
{
private final static Logger log = Logger.getLogger( WorkspaceImpl.class );
public static final MessageSupport messages = MessageSupport.getMessages( WorkspaceImpl.class );
private List<Project> projectList = new ArrayList<Project>();
private SoapuiWorkspaceDocumentConfig workspaceConfig;
private String path = null;
private Set<WorkspaceListener> listeners = new HashSet<WorkspaceListener>();
private ImageIcon workspaceIcon;
private XmlBeansSettingsImpl settings;
private StringToStringMap projectOptions;
private ResolveDialog resolver;
public WorkspaceImpl( String path, StringToStringMap projectOptions ) throws XmlException, IOException
{
if( projectOptions == null )
{
this.projectOptions = new StringToStringMap();
}
else
{
this.projectOptions = projectOptions;
}
File file = new File( path );
this.path = file.getAbsolutePath();
loadWorkspace( file );
workspaceIcon = UISupport.createImageIcon( "/workspace.gif" );
for( WorkspaceListener listener : SoapUI.getListenerRegistry().getListeners( WorkspaceListener.class ) )
{
addWorkspaceListener( listener );
}
}
public void switchWorkspace( File file ) throws SoapUIException
{
// check first if valid workspace file
if( file.exists() )
{
try
{
SoapuiWorkspaceDocumentConfig.Factory.parse( file );
}
catch( Exception e )
{
throw new SoapUIException( messages.get( "FailedToLoadWorkspaceException" ) + e.toString() );
}
}
fireWorkspaceSwitching();
while( projectList.size() > 0 )
{
Project project = projectList.remove( 0 );
try
{
fireProjectRemoved( project );
}
finally
{
project.release();
}
}
try
{
String oldName = getName();
loadWorkspace( file );
this.path = file.getAbsolutePath();
for( Project project : projectList )
{
fireProjectAdded( project );
}
notifyPropertyChanged( ModelItem.NAME_PROPERTY, oldName, getName() );
}
catch( Exception e )
{
SoapUI.logError( e );
}
fireWorkspaceSwitched();
}
public void loadWorkspace( File file ) throws XmlException, IOException
{
if( file.exists() )
{
log.info( messages.get( "FailedToLoadWorkspaceFrom", file.getAbsolutePath() ) );
workspaceConfig = SoapuiWorkspaceDocumentConfig.Factory.parse( file );
if( workspaceConfig.getSoapuiWorkspace().getSettings() == null )
workspaceConfig.getSoapuiWorkspace().addNewSettings();
setPath( file.getAbsolutePath() );
settings = new XmlBeansSettingsImpl( this, SoapUI.getSettings(), workspaceConfig.getSoapuiWorkspace()
.getSettings() );
boolean closeOnStartup = getSettings().getBoolean( UISettings.CLOSE_PROJECTS );
List<WorkspaceProjectConfig> projects = workspaceConfig.getSoapuiWorkspace().getProjectList();
for( int i = 0; i < projects.size(); i++ )
{
WorkspaceProjectConfig wsc = projects.get( i );
String str = PathUtils.denormalizePath( wsc.getStringValue() );
str = PathUtils.adjustRelativePath( str, getProjectRoot(), this );
try
{
// WsdlProject project = new WsdlProject( str, this, false,
// !closeOnStartup &&
// wsc.getStatus() != Status.CLOSED && wsc.getType() !=
// Type.REMOTE, wsc.getName(), null);
WsdlProject project = ( WsdlProject )ProjectFactoryRegistry.getProjectFactory( "wsdl" ).createNew( str,
this, false, !closeOnStartup && wsc.getStatus() != Status.CLOSED && wsc.getType() != Type.REMOTE,
wsc.getName(), null );
projectList.add( project );
}
catch( Exception e )
{
UISupport.showErrorMessage( messages.get( "FailedToLoadProjectInWorkspace", str ) + e.getMessage() );
SoapUI.logError( e );
}
}
}
else
{
workspaceConfig = SoapuiWorkspaceDocumentConfig.Factory.newInstance();
workspaceConfig.addNewSoapuiWorkspace().setName( messages.get( "DefaultWorkspaceName" ) );
workspaceConfig.getSoapuiWorkspace().addNewSettings();
settings = new XmlBeansSettingsImpl( this, SoapUI.getSettings(), workspaceConfig.getSoapuiWorkspace()
.getSettings() );
}
}
public void setPath( String path )
{
this.path = path;
}
public Map<String, Project> getProjects()
{
Map<String, Project> result = new HashMap<String, Project>();
for( Project project : projectList )
{
result.put( project.getName(), project );
}
return result;
}
public void setName( String name )
{
String oldName = getName();
workspaceConfig.getSoapuiWorkspace().setName( name );
notifyPropertyChanged( ModelItem.NAME_PROPERTY, oldName, name );
}
public void setDescription( String description )
{
String oldDescription = getDescription();
workspaceConfig.getSoapuiWorkspace().setDescription( description );
notifyPropertyChanged( ModelItem.DESCRIPTION_PROPERTY, oldDescription, description );
}
public String getName()
{
return workspaceConfig.getSoapuiWorkspace().isSetName() ? workspaceConfig.getSoapuiWorkspace().getName()
: messages.get( "DefaultWorkspaceName" );
}
public Project getProjectAt( int index )
{
return projectList.get( index );
}
public Project getProjectByName( String projectName )
{
for( Project project : projectList )
{
if( project.getName().equals( projectName ) )
return project;
}
return null;
}
public int getProjectCount()
{
return projectList.size();
}
public void onClose()
{
save( !getSettings().getBoolean( UISettings.AUTO_SAVE_PROJECTS_ON_EXIT ) );
}
public void save( boolean workspaceOnly )
{
save( workspaceOnly, false );
}
public void save( boolean workspaceOnly, boolean skipProjectsWithRunningTests )
{
try
{
// not saved?
if( path == null )
{
File file = UISupport.getFileDialogs().saveAs( this, messages.get( "SaveWorkspace.Title" ), ".xml",
"XML Files (*.xml)", null );
if( file == null )
return;
path = file.getAbsolutePath();
}
List<WorkspaceProjectConfig> projects = new ArrayList<WorkspaceProjectConfig>();
// save projects first
for( int c = 0; c < getProjectCount(); c++ )
{
WsdlProject project = ( WsdlProject )getProjectAt( c );
if( !workspaceOnly )
{
if( skipProjectsWithRunningTests && SoapUI.getTestMonitor().hasRunningTests( project ) )
{
log.warn( messages.get( "ProjectHasRunningTests.Warning", project.getName() ) );
}
else
{
String path = project.getPath();
if( !StringUtils.hasContent( path ) )
{
if( UISupport.confirm( messages.get( "ProjectHasNotBeenSaved.Label", project.getName() ),
messages.get( "ProjectHasNotBeenSaved.Title" ) ) )
{
project.save();
}
}
else
{
project.save();
}
}
}
String path = project.getPath();
if( path != null )
{
path = PathUtils.createRelativePath( path, getProjectRoot(), this );
WorkspaceProjectConfig wpc = WorkspaceProjectConfig.Factory.newInstance();
wpc.setStringValue( PathUtils.normalizePath( path ) );
if( project.isRemote() )
wpc.setType( Type.REMOTE );
if( !project.isOpen() )
{
if( project.getEncrypted() == 0 )
{
wpc.setStatus( Status.CLOSED );
}
else
{
wpc.setStatus( Status.CLOSED_AND_ENCRYPTED );
}
}
wpc.setName( project.getName() );
projects.add( wpc );
}
}
workspaceConfig.getSoapuiWorkspace().setProjectArray(
projects.toArray( new WorkspaceProjectConfig[projects.size()] ) );
workspaceConfig.getSoapuiWorkspace().setSoapuiVersion( SoapUI.SOAPUI_VERSION );
File workspaceFile = new File( path );
workspaceConfig.save( workspaceFile, new XmlOptions().setSavePrettyPrint() );
log.info( messages.get( "SavedWorkspace.Info", workspaceFile.getAbsolutePath() ) ); //$NON-NLS-1$ //$NON-NLS-2$
}
catch( IOException e )
{
log.error( messages.get( "FailedToSaveWorkspace.Error" ) + e.getMessage(), e ); //$NON-NLS-1$
}
}
public void addWorkspaceListener( WorkspaceListener listener )
{
listeners.add( listener );
}
public void removeWorkspaceListener( WorkspaceListener listener )
{
listeners.remove( listener );
}
public Project importProject( String fileName ) throws SoapUIException
{
File projectFile = new File( fileName );
WsdlProject project = ( WsdlProject )ProjectFactoryRegistry.getProjectFactory( "wsdl" ).createNew(
projectFile.getAbsolutePath(), this );
projectList.add( project );
fireProjectAdded( project );
resolveProject( project );
save( true );
return project;
}
public void resolveProject( WsdlProject project )
{
if( resolver == null )
{
resolver = new ResolveDialog( "Resolve Project", "Resolve imported project", null );
resolver.setShowOkMessage( false );
}
resolver.resolve( project );
}
public WsdlProject createProject( String name ) throws SoapUIException
{
File projectFile = new File( createProjectFileName( name ) );
File file = UISupport.getFileDialogs().saveAs( this, messages.get( "CreateProject.Title" ), ".xml",
"XML Files (*.xml)", projectFile );
if( file == null )
return null;
return createProject( name, file );
}
public WsdlProject createProject( String name, File file ) throws SoapUIException
{
File projectFile = file;
while( projectFile != null && projectFile.exists() )
{
Boolean result = Boolean.FALSE;
while( !result.booleanValue() )
{
result = UISupport.confirmOrCancel( messages.get( "OverwriteProject.Label" ),
messages.get( "OverwriteProject.Title" ) );
if( result == null )
return null;
if( result.booleanValue() )
{
projectFile.delete();
}
else
{
projectFile = UISupport.getFileDialogs().saveAs( this, messages.get( "CreateProject.Title" ), ".xml",
"XML Files (*.xml)", projectFile ); //$NON-NLS-1$
if( projectFile == null )
return null;
else
break;
}
}
}
// WsdlProject project = new WsdlProject( projectFile == null ? null :
// projectFile.getAbsolutePath(), this );
WsdlProject project = ( WsdlProject )ProjectFactoryRegistry.getProjectFactory( WsdlProjectFactory.WSDL_TYPE )
.createNew( null, this );
project.setName( name );
projectList.add( project );
fireProjectAdded( project );
try
{
if( projectFile != null )
project.saveAs( projectFile.getAbsolutePath() );
}
catch( IOException e )
{
log.error( messages.get( "FailedToSaveProject.Error" ) + e.getMessage(), e );
}
// save( true );
return project;
}
private void fireProjectOpened( Project project )
{
for( Iterator<WorkspaceListener> iter = listeners.iterator(); iter.hasNext(); )
{
WorkspaceListener listener = iter.next();
listener.projectOpened( project );
}
}
private void fireProjectClosed( Project project )
{
for( Iterator<WorkspaceListener> iter = listeners.iterator(); iter.hasNext(); )
{
WorkspaceListener listener = iter.next();
listener.projectClosed( project );
}
}
private void fireProjectAdded( Project project )
{
for( Iterator<WorkspaceListener> iter = listeners.iterator(); iter.hasNext(); )
{
WorkspaceListener listener = iter.next();
listener.projectAdded( project );
}
}
private void fireWorkspaceSwitching()
{
for( Iterator<WorkspaceListener> iter = listeners.iterator(); iter.hasNext(); )
{
WorkspaceListener listener = iter.next();
listener.workspaceSwitching( this );
}
}
private void fireWorkspaceSwitched()
{
for( Iterator<WorkspaceListener> iter = listeners.iterator(); iter.hasNext(); )
{
WorkspaceListener listener = iter.next();
listener.workspaceSwitched( this );
}
}
private String createProjectFileName( String name )
{
return name + "-soapui-project.xml"; //$NON-NLS-1$
}
public void removeProject( Project project )
{
int ix = projectList.indexOf( project );
if( ix == -1 )
throw new RuntimeException( "Project [" + project.getName() + "] not available in workspace for removal" );
projectList.remove( ix );
try
{
fireProjectRemoved( project );
}
finally
{
project.release();
// workspaceConfig.getSoapuiWorkspace().removeProject( ix );
}
}
public Project reloadProject( Project project ) throws SoapUIException
{
int ix = projectList.indexOf( project );
if( ix == -1 )
throw new RuntimeException( "Project [" + project.getName() //$NON-NLS-1$
+ "] not available in workspace for reload" ); //$NON-NLS-1$
projectList.remove( ix );
fireProjectRemoved( project );
String tempName = project.getName();
project.release();
project = ( WsdlProject )ProjectFactoryRegistry.getProjectFactory( "wsdl" ).createNew( project.getPath(), this,
false, true, tempName, null );
projectList.add( ix, project );
fireProjectAdded( project );
fireProjectOpened( project );
return project;
}
private void fireProjectRemoved( Project project )
{
WorkspaceListener[] listenerArray = listeners.toArray( new WorkspaceListener[listeners.size()] );
for( int c = 0; c < listenerArray.length; c++ )
{
listenerArray[c].projectRemoved( project );
}
}
public ImageIcon getIcon()
{
return workspaceIcon;
}
public Settings getSettings()
{
return settings;
}
public int getIndexOfProject( Project project )
{
return projectList.indexOf( project );
}
public String getPath()
{
return path;
}
public String getProjectRoot()
{
return workspaceConfig.getSoapuiWorkspace().getProjectRoot();
}
public void setProjectRoot( String workspaceRoot )
{
workspaceConfig.getSoapuiWorkspace().setProjectRoot( workspaceRoot );
}
public void release()
{
settings.release();
for( Project project : projectList )
project.release();
}
public List<? extends Project> getProjectList()
{
return projectList;
}
public String getDescription()
{
return workspaceConfig.getSoapuiWorkspace().getDescription();
}
public WsdlProject importRemoteProject( String url ) throws SoapUIException
{
// WsdlProject project = new WsdlProject( url, this, false );
WsdlProject project = ( WsdlProject )ProjectFactoryRegistry.getProjectFactory( "wsdl" ).createNew( url, this,
false );
projectList.add( project );
fireProjectAdded( project );
resolveProject( project );
save( true );
return project;
}
public void closeProject( Project project )
{
int oldProjectEncrypt = ( ( WsdlProject )project ).getEncrypted();
int ix = projectList.indexOf( project );
if( ix == -1 )
throw new RuntimeException( "Project [" + project.getName() + "] not available in workspace for close" );
projectList.remove( ix );
fireProjectRemoved( project );
fireProjectClosed( project );
String name = project.getName();
project.release();
try
{
// project = new WsdlProject( project.getPath(), this, false, false,
// name, null );
project = ProjectFactoryRegistry.getProjectFactory( WsdlProjectFactory.WSDL_TYPE ).createNew(
project.getPath(), this, false, false, name, null );
( ( WsdlProject )project ).setEncrypted( oldProjectEncrypt );
projectList.add( ix, project );
fireProjectAdded( project );
}
catch( Exception e )
{
UISupport.showErrorMessage( messages.get( "FailedToCloseProject.Error", name ) + e.getMessage() );
SoapUI.logError( e );
}
}
public List<Project> getOpenProjectList()
{
List<Project> availableProjects = new ArrayList<Project>();
for( Project project : projectList )
if( project.isOpen() )
availableProjects.add( project );
return availableProjects;
}
public Project openProject( Project project ) throws SoapUIException
{
return reloadProject( project );
}
public String getId()
{
return String.valueOf( hashCode() );
}
public List<? extends ModelItem> getChildren()
{
return getProjectList();
}
public ModelItem getParent()
{
return null;
}
public void inspectProjects()
{
for( int cnt = 0; cnt < projectList.size(); cnt++ )
{
Project project = projectList.get( cnt );
if( project.isOpen() )
project.inspect();
}
}
public String getProjectPassword( String name )
{
return projectOptions.get( name );
}
public void clearProjectPassword( String name )
{
projectOptions.remove( name );
}
}