package org.apache.maven.continuum.xmlrpc.server;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import net.sf.dozer.util.mapping.DozerBeanMapperSingletonWrapper;
import net.sf.dozer.util.mapping.MapperIF;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.continuum.buildagent.NoBuildAgentException;
import org.apache.continuum.buildagent.NoBuildAgentInGroupException;
import org.apache.continuum.builder.distributed.manager.DistributedBuildManager;
import org.apache.continuum.buildmanager.BuildManagerException;
import org.apache.continuum.buildmanager.BuildsManager;
import org.apache.continuum.configuration.BuildAgentConfigurationException;
import org.apache.continuum.configuration.ContinuumConfigurationException;
import org.apache.continuum.dao.SystemConfigurationDao;
import org.apache.continuum.purge.ContinuumPurgeManagerException;
import org.apache.continuum.purge.PurgeConfigurationServiceException;
import org.apache.continuum.repository.RepositoryServiceException;
import org.apache.continuum.utils.release.ReleaseUtil;
import org.apache.continuum.xmlrpc.release.ContinuumReleaseResult;
import org.apache.continuum.xmlrpc.repository.DirectoryPurgeConfiguration;
import org.apache.continuum.xmlrpc.repository.LocalRepository;
import org.apache.continuum.xmlrpc.repository.RepositoryPurgeConfiguration;
import org.apache.continuum.xmlrpc.utils.BuildTrigger;
import org.apache.maven.continuum.Continuum;
import org.apache.maven.continuum.ContinuumException;
import org.apache.maven.continuum.builddefinition.BuildDefinitionServiceException;
import org.apache.maven.continuum.configuration.ConfigurationException;
import org.apache.maven.continuum.configuration.ConfigurationService;
import org.apache.maven.continuum.configuration.ConfigurationStoringException;
import org.apache.maven.continuum.execution.ContinuumBuildExecutorConstants;
import org.apache.maven.continuum.installation.InstallationException;
import org.apache.maven.continuum.installation.InstallationService;
import org.apache.maven.continuum.project.ContinuumProjectState;
import org.apache.maven.continuum.project.builder.ContinuumProjectBuildingResult;
import org.apache.maven.continuum.security.ContinuumRoleConstants;
import org.apache.maven.continuum.store.ContinuumStoreException;
import org.apache.maven.continuum.xmlrpc.project.AddingResult;
import org.apache.maven.continuum.xmlrpc.project.BuildAgentConfiguration;
import org.apache.maven.continuum.xmlrpc.project.BuildAgentGroupConfiguration;
import org.apache.maven.continuum.xmlrpc.project.BuildDefinition;
import org.apache.maven.continuum.xmlrpc.project.BuildDefinitionTemplate;
import org.apache.maven.continuum.xmlrpc.project.BuildProjectTask;
import org.apache.maven.continuum.xmlrpc.project.BuildResult;
import org.apache.maven.continuum.xmlrpc.project.BuildResultSummary;
import org.apache.maven.continuum.xmlrpc.project.Project;
import org.apache.maven.continuum.xmlrpc.project.ProjectGroup;
import org.apache.maven.continuum.xmlrpc.project.ProjectGroupSummary;
import org.apache.maven.continuum.xmlrpc.project.ProjectNotifier;
import org.apache.maven.continuum.xmlrpc.project.ProjectScmRoot;
import org.apache.maven.continuum.xmlrpc.project.ProjectSummary;
import org.apache.maven.continuum.xmlrpc.project.ReleaseListenerSummary;
import org.apache.maven.continuum.xmlrpc.project.Schedule;
import org.apache.maven.continuum.xmlrpc.system.Installation;
import org.apache.maven.continuum.xmlrpc.system.Profile;
import org.apache.maven.continuum.xmlrpc.system.SystemConfiguration;
import org.apache.maven.scm.provider.svn.repository.SvnScmProviderRepository;
import org.codehaus.plexus.redback.authorization.AuthorizationException;
import org.codehaus.plexus.redback.role.RoleManager;
import org.codehaus.plexus.redback.role.RoleManagerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
 * @version $Id$
 * @plexus.component role="org.apache.maven.continuum.xmlrpc.server.ContinuumXmlRpcComponent" role-hint="org.apache.maven.continuum.xmlrpc.ContinuumService"
 */
public class ContinuumServiceImpl
    extends AbstractContinuumSecureService
{
    private static final String NAME_VALID_EXPRESSION = "[A-Za-z0-9_.\\s\\-():\\/,]*";

    private static final String DIRECTORY_VALID_EXPRESSION = "[A-Za-z0-9_/\\s:.\\\\-]*";

    private static final String URL_VALID_EXPRESSION = "[A-Za-z0-9_.@:/-]*";

    private static final String PROJECT_VERSION_VALID_EXPRESSION = "[a-zA-Z0-9.-]*";

    private static final String PROJECT_SCM_URL_VALID_EXPRESSION = "[a-zA-Z0-9_.:${}#~=@\\/|\\[\\]-]*";

    private static final String PROJECT_SCM_TAG_VALID_EXPRESSION = "[a-zA-Z0-9_.:@\\/|#~=\\[\\]-]*";

    private static final String PROJECT_ARTIFACT_ID_VALID_EXPRESSION = "[A-Za-z0-9\\-]*";

    private static final String PROJECT_EXECUTOR_OR_BUILDDEF_TYPE_VALID_EXPRESSION = "maven2|maven-1|ant|shell";

    private static final String SCHEDULE_CRON_VALID_EXPRESSION = "[A-Z0-9\\s*/,-?#]*";

    private static final String PROJECTGROUP_ID_VALID_EXPRESSION = "[a-zA-Z0-9_.\\s\\-]*";

    private static final String REPOSITORY_LAYOUT_VALID_EXPRESSION = "default|legacy";

    private static final String BUILD_DEFINITION_ARGUMENTS_VALID_EXPRESSION = "[!A-Za-z0-9_./=,${}\":\\s\\\\-]*";

    private static final String BUILD_DEFINITION_GOALS_VALID_EXPRESSION = "[A-Za-z0-9_:\\s\\-]*";

    private static final String BUILD_DEFINITION_BUILD_FILE_VALID_EXPRESSION = "[A-Za-z0-9_.\\-/\\\\]*";

    private static final String INSTALLATION_VARNAME_VALID_EXPRESSION = "[A-Za-z][A-Za-z0-9_]*";

    private static final String INSTALLATION_VARVALUE_VALID_EXPRESSION = "(?:[~A-Za-z0-9_.:=${}\\\\/\\-+]|\\s|[()])*";

    private static final String INSTALLATION_TYPE_VALID_EXPRESSION = "jdk|maven2|maven1|ant|envvar";

    private static final String DIRECTORY_TYPE_VALID_EXPRESSION = "releases|buildOutput";

    private static final String NOTIFIER_TYPE_VALID_EXPRESSION = "irc|jabber|msn|mail|wagon";

    private static final String USERNAME_VALID_EXPRESSION = "[a-zA-Z_0-9\\-.@]*";

    private static final MapperIF mapper = DozerBeanMapperSingletonWrapper.getInstance();

    private final Logger logger = LoggerFactory.getLogger( ContinuumServiceImpl.class );

    /**
     * @plexus.requirement
     */
    private Continuum continuum;

    /**
     * @plexus.requirement
     */
    private SystemConfigurationDao systemConfigurationDao;

    /**
     * @plexus.requirement role-hint="default"
     */
    private RoleManager roleManager;

    /**
     * @plexus.requirement role-hint="parallel"
     */
    private BuildsManager parallelBuildsManager;

    /**
     * @plexus.requirement
     */
    private DistributedBuildManager distributedBuildManager;

    public boolean ping()
        throws ContinuumException
    {
        return true;
    }

    // ----------------------------------------------------------------------
    // Projects
    // ----------------------------------------------------------------------

    public List<ProjectSummary> getProjects( int projectGroupId )
        throws ContinuumException
    {
        checkViewProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );

        List<ProjectSummary> projectsList = new ArrayList<ProjectSummary>();

        Collection<org.apache.maven.continuum.model.project.Project> projects = continuum.getProjectsInGroup(
            projectGroupId );
        if ( projects != null )
        {
            for ( org.apache.maven.continuum.model.project.Project project : projects )
            {
                ProjectSummary ps = populateProjectSummary( project );
                projectsList.add( ps );
            }
        }
        return projectsList;
    }

    public ProjectSummary getProjectSummary( int projectId )
        throws ContinuumException
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        checkViewProjectGroupAuthorization( project.getProjectGroup().getName() );

        return populateProjectSummary( project );
    }

    public Project getProjectWithAllDetails( int projectId )
        throws ContinuumException
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProjectWithAllDetails( projectId );

        checkViewProjectGroupAuthorization( project.getProjectGroup().getName() );

        return populateProject( project );
    }

    public int removeProject( int projectId )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );

        checkRemoveProjectFromGroupAuthorization( ps.getProjectGroup().getName() );

        continuum.removeProject( projectId );

        return 0;
    }

    public ProjectSummary updateProject( ProjectSummary project )
        throws ContinuumException
    {
        if ( StringUtils.isNotBlank( project.getName() ) && !project.getName().matches( NAME_VALID_EXPRESSION ) )
        //!GenericValidator.matchRegexp( project.getName(), NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Name contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( project.getScmTag() ) && !project.getScmTag().matches(
            PROJECT_SCM_TAG_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Scm Tag contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( project.getScmUrl() ) && !project.getScmUrl().matches(
            PROJECT_SCM_URL_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Scm Url contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( project.getVersion() ) && !project.getVersion().matches(
            PROJECT_VERSION_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Version contains invalid characters" );
        }

        ProjectSummary ps = getProjectSummary( project.getId() );

        checkRemoveProjectFromGroupAuthorization( ps.getProjectGroup().getName() );

        org.apache.maven.continuum.model.project.Project p = continuum.getProject( project.getId() );

        p.setName( project.getName() );
        p.setVersion( project.getVersion() );
        p.setScmUrl( project.getScmUrl() );
        p.setScmUseCache( project.isScmUseCache() );
        p.setScmUsername( project.getScmUsername() );
        p.setScmPassword( project.getScmPassword() );
        p.setScmTag( project.getScmTag() );

        continuum.updateProject( p );

        return getProjectSummary( project.getId() );
    }

    // ----------------------------------------------------------------------
    // Projects Groups
    // ----------------------------------------------------------------------

    public List<ProjectGroupSummary> getAllProjectGroups()
        throws ContinuumException
    {
        Collection<org.apache.maven.continuum.model.project.ProjectGroup> pgList = continuum.getAllProjectGroups();
        List<ProjectGroupSummary> result = new ArrayList<ProjectGroupSummary>();
        for ( org.apache.maven.continuum.model.project.ProjectGroup projectGroup : pgList )
        {
            try
            {
                if ( isAuthorized( ContinuumRoleConstants.CONTINUUM_VIEW_GROUP_OPERATION, projectGroup.getName() ) )
                {
                    result.add( populateProjectGroupSummary( projectGroup ) );
                }
            }
            catch ( AuthorizationException e )
            {
                throw new ContinuumException( "error authorizing request." );
            }
        }
        return result;
    }

    public ProjectGroup getProjectGroup( int projectGroupId )
        throws ContinuumException
    {
        ProjectGroup result = null;
        org.apache.maven.continuum.model.project.ProjectGroup projectGroup = continuum.getProjectGroup(
            projectGroupId );
        try
        {
            if ( isAuthorized( ContinuumRoleConstants.CONTINUUM_VIEW_GROUP_OPERATION, projectGroup.getName() ) )
            {
                result = populateProjectGroupWithAllDetails( projectGroup );
            }
        }
        catch ( AuthorizationException e )
        {
            throw new ContinuumException( "error authorizing request." );
        }
        return result;
    }

    public List<ProjectGroup> getAllProjectGroupsWithAllDetails()
        throws ContinuumException
    {
        Collection<org.apache.maven.continuum.model.project.ProjectGroup> pgList =
            continuum.getAllProjectGroupsWithBuildDetails();
        List<ProjectGroup> result = new ArrayList<ProjectGroup>();
        for ( org.apache.maven.continuum.model.project.ProjectGroup projectGroup : pgList )
        {
            try
            {
                if ( isAuthorized( ContinuumRoleConstants.CONTINUUM_VIEW_GROUP_OPERATION, projectGroup.getName() ) )
                {
                    result.add( populateProjectGroupWithAllDetails( projectGroup ) );
                }
            }
            catch ( AuthorizationException e )
            {
                throw new ContinuumException( "error authorizing request." );
            }
        }
        return result;
    }

    public List<ProjectGroup> getAllProjectGroupsWithProjects()
        throws ContinuumException
    {
        return getAllProjectGroupsWithAllDetails();
    }

    protected String getProjectGroupName( int projectGroupId )
        throws ContinuumException
    {
        ProjectGroupSummary pgs = getPGSummary( projectGroupId );
        return pgs.getName();
    }

    private ProjectGroupSummary getPGSummary( int projectGroupId )
        throws ContinuumException
    {
        org.apache.maven.continuum.model.project.ProjectGroup projectGroup = continuum.getProjectGroup(
            projectGroupId );

        checkViewProjectGroupAuthorization( projectGroup.getName() );
        return populateProjectGroupSummary( projectGroup );
    }

    public ProjectGroupSummary getProjectGroupSummary( int projectGroupId )
        throws ContinuumException
    {
        checkViewProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );

        org.apache.maven.continuum.model.project.ProjectGroup projectGroup = continuum.getProjectGroup(
            projectGroupId );
        return populateProjectGroupSummary( projectGroup );
    }

    public ProjectGroup getProjectGroupWithProjects( int projectGroupId )
        throws ContinuumException
    {
        checkViewProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );

        org.apache.maven.continuum.model.project.ProjectGroup projectGroup = continuum.getProjectGroupWithProjects(
            projectGroupId );
        return populateProjectGroupWithAllDetails( projectGroup );
    }

    public int removeProjectGroup( int projectGroupId )
        throws ContinuumException
    {
        checkRemoveProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );

        continuum.removeProjectGroup( projectGroupId );
        return 0;
    }

    public ProjectGroupSummary updateProjectGroup( ProjectGroupSummary projectGroup )
        throws ContinuumException
    {
        if ( projectGroup == null )
        {
            return null;
        }

        checkModifyProjectGroupAuthorization( getProjectGroupName( projectGroup.getId() ) );

        if ( StringUtils.isEmpty( projectGroup.getName() ) )
        {
            throw new ContinuumException( "project group name is required" );
        }
        else if ( StringUtils.isEmpty( projectGroup.getName().trim() ) )
        {
            throw new ContinuumException( "project group name can't be spaces" );
        }

        if ( !projectGroup.getName().matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "ProjectGroup Name contains invalid characters" );
        }

        org.apache.maven.continuum.model.project.ProjectGroup pg = continuum.getProjectGroupWithProjects(
            projectGroup.getId() );

        // need to administer roles since they are based off of this
        // todo convert everything like to work off of string keys
        if ( !projectGroup.getName().equals( pg.getName() ) )
        {
            try
            {
                roleManager.updateRole( "project-administrator", pg.getName(), projectGroup.getName() );
                roleManager.updateRole( "project-developer", pg.getName(), projectGroup.getName() );
                roleManager.updateRole( "project-user", pg.getName(), projectGroup.getName() );

                pg.setName( projectGroup.getName() );
            }
            catch ( RoleManagerException e )
            {
                throw new ContinuumException( "unable to rename the project group", e );
            }
        }

        pg.setDescription( StringEscapeUtils.escapeXml( projectGroup.getDescription() ) );

        org.apache.continuum.model.repository.LocalRepository repo =
            new org.apache.continuum.model.repository.LocalRepository();
        pg.setLocalRepository( populateLocalRepository( projectGroup.getLocalRepository(), repo ) );

        continuum.updateProjectGroup( pg );
        return getProjectGroupSummary( projectGroup.getId() );
    }

    public ProjectGroupSummary addProjectGroup( String groupName, String groupId, String description )
        throws Exception
    {
        if ( StringUtils.isNotBlank( groupId ) && !groupId.matches( PROJECTGROUP_ID_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "ProjectGroup Id contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( groupName ) && !groupName.matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "ProjectGroup Name contains invalid characters" );
        }

        org.apache.maven.continuum.model.project.ProjectGroup pg =
            new org.apache.maven.continuum.model.project.ProjectGroup();
        pg.setName( groupName );
        pg.setGroupId( groupId );
        pg.setDescription( StringEscapeUtils.escapeXml( description ) );
        continuum.addProjectGroup( pg );
        return populateProjectGroupSummary( continuum.getProjectGroupByGroupId( groupId ) );
    }

    public ProjectNotifier getNotifier( int projectid, int notifierId )
        throws ContinuumException
    {
        return populateProjectNotifier( continuum.getNotifier( projectid, notifierId ) );
    }

    public ProjectNotifier updateNotifier( int projectid, ProjectNotifier newNotifier )
        throws ContinuumException
    {
        if ( StringUtils.isNotBlank( newNotifier.getType() ) && !newNotifier.getType().matches(
            NOTIFIER_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Notifier Type can only be 'irc, jabber, msn, mail or wagon" );
        }

        org.apache.maven.continuum.model.project.ProjectNotifier notifier = continuum.getNotifier( projectid,
                                                                                                   newNotifier.getId() );
        notifier.setConfiguration( newNotifier.getConfiguration() );
        notifier.setFrom( newNotifier.getFrom() );
        notifier.setRecipientType( newNotifier.getRecipientType() );
        notifier.setType( newNotifier.getType() );
        notifier.setEnabled( newNotifier.isEnabled() );
        notifier.setSendOnError( newNotifier.isSendOnError() );
        notifier.setSendOnFailure( newNotifier.isSendOnFailure() );
        notifier.setSendOnSuccess( newNotifier.isSendOnSuccess() );
        notifier.setSendOnWarning( newNotifier.isSendOnWarning() );
        return populateProjectNotifier( continuum.updateNotifier( projectid, notifier ) );
    }

    public ProjectNotifier addNotifier( int projectid, ProjectNotifier newNotifier )
        throws ContinuumException
    {
        if ( StringUtils.isNotBlank( newNotifier.getType() ) && !newNotifier.getType().matches(
            NOTIFIER_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Notifier Type can only be 'irc, jabber, msn, mail or wagon'" );
        }

        org.apache.maven.continuum.model.project.ProjectNotifier notifier =
            new org.apache.maven.continuum.model.project.ProjectNotifier();
        notifier.setConfiguration( newNotifier.getConfiguration() );
        notifier.setFrom( newNotifier.getFrom() );
        notifier.setRecipientType( newNotifier.getRecipientType() );
        notifier.setType( newNotifier.getType() );
        notifier.setEnabled( newNotifier.isEnabled() );
        notifier.setSendOnError( newNotifier.isSendOnError() );
        notifier.setSendOnFailure( newNotifier.isSendOnFailure() );
        notifier.setSendOnSuccess( newNotifier.isSendOnSuccess() );
        notifier.setSendOnWarning( newNotifier.isSendOnWarning() );
        return populateProjectNotifier( continuum.addNotifier( projectid, notifier ) );
    }

    public int removeNotifier( int projectid, int notifierId )
        throws ContinuumException
    {
        continuum.removeNotifier( projectid, notifierId );
        return 0;
    }

    public ProjectNotifier getGroupNotifier( int projectgroupid, int notifierId )
        throws ContinuumException
    {
        return populateProjectNotifier( continuum.getGroupNotifier( projectgroupid, notifierId ) );
    }

    public ProjectNotifier updateGroupNotifier( int projectgroupid, ProjectNotifier newNotifier )
        throws ContinuumException
    {
        if ( StringUtils.isNotBlank( newNotifier.getType() ) && !newNotifier.getType().matches(
            NOTIFIER_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Notifier Type can only be 'irc, jabber, msn, mail, or wagon" );
        }

        org.apache.maven.continuum.model.project.ProjectNotifier notifier = continuum.getGroupNotifier( projectgroupid,
                                                                                                        newNotifier.getId() );
        notifier.setConfiguration( newNotifier.getConfiguration() );
        notifier.setFrom( newNotifier.getFrom() );
        notifier.setRecipientType( newNotifier.getRecipientType() );
        notifier.setType( newNotifier.getType() );
        notifier.setEnabled( newNotifier.isEnabled() );
        notifier.setSendOnError( newNotifier.isSendOnError() );
        notifier.setSendOnFailure( newNotifier.isSendOnFailure() );
        notifier.setSendOnSuccess( newNotifier.isSendOnSuccess() );
        notifier.setSendOnWarning( newNotifier.isSendOnWarning() );
        return populateProjectNotifier( continuum.updateGroupNotifier( projectgroupid, notifier ) );
    }

    public ProjectNotifier addGroupNotifier( int projectgroupid, ProjectNotifier newNotifier )
        throws ContinuumException
    {
        org.apache.maven.continuum.model.project.ProjectNotifier notifier =
            new org.apache.maven.continuum.model.project.ProjectNotifier();

        if ( StringUtils.isNotBlank( newNotifier.getType() ) && !newNotifier.getType().matches(
            NOTIFIER_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Notifier Type can only be 'irc, jabber, msn, mail or wagon" );
        }

        notifier.setConfiguration( newNotifier.getConfiguration() );
        notifier.setFrom( newNotifier.getFrom() );
        notifier.setRecipientType( newNotifier.getRecipientType() );
        notifier.setType( newNotifier.getType() );
        notifier.setEnabled( newNotifier.isEnabled() );
        notifier.setSendOnError( newNotifier.isSendOnError() );
        notifier.setSendOnFailure( newNotifier.isSendOnFailure() );
        notifier.setSendOnSuccess( newNotifier.isSendOnSuccess() );
        notifier.setSendOnWarning( newNotifier.isSendOnWarning() );
        return populateProjectNotifier( continuum.addGroupNotifier( projectgroupid, notifier ) );
    }

    public int removeGroupNotifier( int projectgroupid, int notifierId )
        throws ContinuumException
    {
        continuum.removeGroupNotifier( projectgroupid, notifierId );
        return 0;
    }

    // ----------------------------------------------------------------------
    // Build Definitions
    // ----------------------------------------------------------------------

    public List<BuildDefinition> getBuildDefinitionsForProject( int projectId )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );

        checkViewProjectGroupAuthorization( ps.getProjectGroup().getName() );

        List<org.apache.maven.continuum.model.project.BuildDefinition> bds = continuum.getBuildDefinitionsForProject(
            projectId );

        List<BuildDefinition> result = new ArrayList<BuildDefinition>();
        for ( org.apache.maven.continuum.model.project.BuildDefinition bd : bds )
        {
            result.add( populateBuildDefinition( bd ) );
        }
        return result;
    }

    public List<BuildDefinition> getBuildDefinitionsForProjectGroup( int projectGroupId )
        throws ContinuumException
    {
        checkViewProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );

        List<org.apache.maven.continuum.model.project.BuildDefinition> bds =
            continuum.getBuildDefinitionsForProjectGroup( projectGroupId );

        List<BuildDefinition> result = new ArrayList<BuildDefinition>();
        for ( org.apache.maven.continuum.model.project.BuildDefinition bd : bds )
        {
            result.add( populateBuildDefinition( bd ) );
        }
        return result;
    }

    public BuildDefinition getBuildDefinition( int buildDefinitionId )
        throws Exception
    {
        org.apache.maven.continuum.model.project.BuildDefinition bd = continuum.getBuildDefinition( buildDefinitionId );

        return populateBuildDefinition( bd );
    }

    public int removeBuildDefinitionFromProjectGroup( int projectGroupId, int buildDefinitionId )
        throws ContinuumException
    {
        checkRemoveGroupBuildDefinitionAuthorization( getProjectGroupName( projectGroupId ) );

        continuum.removeBuildDefinitionFromProjectGroup( projectGroupId, buildDefinitionId );
        return 0;
    }

    public BuildDefinition updateBuildDefinitionForProject( int projectId, BuildDefinition buildDef )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );

        checkModifyProjectBuildDefinitionAuthorization( ps.getProjectGroup().getName() );
        org.apache.maven.continuum.model.project.BuildDefinition newbd = continuum.getBuildDefinition(
            buildDef.getId() );
        org.apache.maven.continuum.model.project.BuildDefinition bd = populateBuildDefinition( buildDef, newbd );
        bd = continuum.updateBuildDefinitionForProject( projectId, bd );
        return populateBuildDefinition( bd );
    }

    public BuildDefinition updateBuildDefinitionForProjectGroup( int projectGroupId, BuildDefinition buildDef )
        throws ContinuumException
    {
        checkModifyGroupBuildDefinitionAuthorization( getProjectGroupName( projectGroupId ) );
        org.apache.maven.continuum.model.project.BuildDefinition newbd = continuum.getBuildDefinition(
            buildDef.getId() );
        org.apache.maven.continuum.model.project.BuildDefinition bd = populateBuildDefinition( buildDef, newbd );
        bd = continuum.updateBuildDefinitionForProjectGroup( projectGroupId, bd );
        return populateBuildDefinition( bd );
    }

    public BuildDefinition addBuildDefinitionToProject( int projectId, BuildDefinition buildDef )
        throws ContinuumException
    {
        checkAddProjectBuildDefinitionAuthorization( getProjectSummary( projectId ).getProjectGroup().getName() );

        if ( buildDef.getSchedule() == null )
        {
            throw new ContinuumException( "The schedule can't be null." );
        }
        org.apache.maven.continuum.model.project.BuildDefinition newbd =
            new org.apache.maven.continuum.model.project.BuildDefinition();
        org.apache.maven.continuum.model.project.BuildDefinition bd = populateBuildDefinition( buildDef, newbd );
        bd = continuum.addBuildDefinitionToProject( projectId, bd );
        return populateBuildDefinition( bd );
    }

    public BuildDefinition addBuildDefinitionToProjectGroup( int projectGroupId, BuildDefinition buildDef )
        throws ContinuumException
    {
        checkAddGroupBuildDefinitionAuthorization( getPGSummary( projectGroupId ).getName() );

        if ( buildDef.getSchedule() == null )
        {
            throw new ContinuumException( "The schedule can't be null." );
        }
        org.apache.maven.continuum.model.project.BuildDefinition newbd =
            new org.apache.maven.continuum.model.project.BuildDefinition();
        org.apache.maven.continuum.model.project.BuildDefinition bd = populateBuildDefinition( buildDef, newbd );
        bd = continuum.addBuildDefinitionToProjectGroup( projectGroupId, bd );
        return populateBuildDefinition( bd );
    }

    public List<BuildDefinitionTemplate> getBuildDefinitionTemplates()
        throws Exception
    {
        checkManageBuildDefinitionTemplatesAuthorization();
        List<org.apache.maven.continuum.model.project.BuildDefinitionTemplate> bdts =
            continuum.getBuildDefinitionService().getAllBuildDefinitionTemplate();

        List<BuildDefinitionTemplate> result = new ArrayList<BuildDefinitionTemplate>();
        for ( org.apache.maven.continuum.model.project.BuildDefinitionTemplate bdt : bdts )
        {
            result.add( populateBuildDefinitionTemplate( bdt ) );
        }
        return result;
    }

    // ----------------------------------------------------------------------
    // Building
    // ----------------------------------------------------------------------

    // TODO: delete this since it does exactly the same as buildProject( int projectId )
    public int addProjectToBuildQueue( int projectId )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkBuildProjectInGroupAuthorization( ps.getProjectGroup().getName() );

        continuum.buildProject( projectId, new org.apache.continuum.utils.build.BuildTrigger(
            ContinuumProjectState.TRIGGER_SCHEDULED, "" ) );
        return 0;
    }

    // Alternative to buildProject since that forces TRIGGER_FORCED
    public int addProjectToBuildQueue( int projectId, int buildDefinitionId )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkBuildProjectInGroupAuthorization( ps.getProjectGroup().getName() );

        continuum.buildProject( projectId, buildDefinitionId, new org.apache.continuum.utils.build.BuildTrigger(
            ContinuumProjectState.TRIGGER_SCHEDULED, "" ) );
        return 0;
    }

    public int buildProject( int projectId )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkBuildProjectInGroupAuthorization( ps.getProjectGroup().getName() );

        continuum.buildProject( projectId, new org.apache.continuum.utils.build.BuildTrigger(
            ContinuumProjectState.TRIGGER_SCHEDULED, "" ) );
        return 0;
    }

    public int buildProject( int projectId, int buildDefinitionId )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkBuildProjectInGroupAuthorization( ps.getProjectGroup().getName() );

        buildProjectWithBuildDefinition( projectId, buildDefinitionId,
                                         new org.apache.continuum.utils.build.BuildTrigger(
                                             ContinuumProjectState.TRIGGER_SCHEDULED, "" )
        );
        return 0;
    }

    public int buildProject( int projectId, BuildTrigger xmlrpcBuildTrigger )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkBuildProjectInGroupAuthorization( ps.getProjectGroup().getName() );

        org.apache.continuum.utils.build.BuildTrigger buildTrigger = populateBuildTrigger( xmlrpcBuildTrigger );

        continuum.buildProject( projectId, buildTrigger );
        return 0;
    }

    public int buildProject( int projectId, int buildDefinitionId, BuildTrigger xmlrpcBuildTrigger )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectSummary projectSummary = getProjectSummary( projectId );
        checkBuildProjectInGroupAuthorization( projectSummary.getProjectGroup().getName() );

        org.apache.continuum.utils.build.BuildTrigger buildTrigger = populateBuildTrigger( xmlrpcBuildTrigger );
        buildProjectWithBuildDefinition( projectId, buildDefinitionId, buildTrigger );

        return 0;
    }

    public int buildGroup( int projectGroupId )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectGroupSummary pg = getProjectGroupSummary( projectGroupId );
        checkBuildProjectInGroupAuthorization( pg.getName() );

        continuum.buildProjectGroup( projectGroupId, new org.apache.continuum.utils.build.BuildTrigger(
            ContinuumProjectState.TRIGGER_SCHEDULED, "" ) );

        return 0;
    }

    public int buildGroup( int projectGroupId, int buildDefinitionId )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        ProjectGroupSummary pg = getProjectGroupSummary( projectGroupId );
        checkBuildProjectInGroupAuthorization( pg.getName() );

        continuum.buildProjectGroupWithBuildDefinition( projectGroupId, buildDefinitionId,
                                                        new org.apache.continuum.utils.build.BuildTrigger(
                                                            ContinuumProjectState.TRIGGER_SCHEDULED, "" )
        );

        return 0;
    }

    // ----------------------------------------------------------------------
    // SCM roots
    // ----------------------------------------------------------------------

    public List<ProjectScmRoot> getProjectScmRootByProjectGroup( int projectGroupId )
        throws ContinuumException
    {
        checkViewProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );

        List<org.apache.continuum.model.project.ProjectScmRoot> projectScmRoots =
            continuum.getProjectScmRootByProjectGroup( projectGroupId );

        List<ProjectScmRoot> result = new ArrayList<ProjectScmRoot>( projectScmRoots.size() );
        for ( org.apache.continuum.model.project.ProjectScmRoot projectScmRoot : projectScmRoots )
        {
            result.add( populateProjectScmRoot( projectScmRoot ) );
        }

        return result;
    }

    public ProjectScmRoot getProjectScmRootByProject( int projectId )
        throws ContinuumException
    {
        org.apache.continuum.model.project.ProjectScmRoot projectScmRoot = continuum.getProjectScmRootByProject(
            projectId );

        checkViewProjectGroupAuthorization( projectScmRoot.getProjectGroup().getName() );

        return populateProjectScmRoot( projectScmRoot );
    }

    // ----------------------------------------------------------------------
    // Build Results
    // ----------------------------------------------------------------------

    public BuildResult getLatestBuildResult( int projectId )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkViewProjectGroupAuthorization( ps.getProjectGroup().getName() );

        org.apache.maven.continuum.model.project.BuildResult buildResult = continuum.getLatestBuildResultForProject(
            projectId );

        if ( buildResult != null )
        {
            return getBuildResult( projectId, buildResult.getId() );
        }

        return null;
    }

    public BuildResult getBuildResult( int projectId, int buildId )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkViewProjectGroupAuthorization( ps.getProjectGroup().getName() );

        return populateBuildResult( continuum.getBuildResult( buildId ) );
    }

    public List<BuildResultSummary> getBuildResultsForProject( int projectId )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkViewProjectGroupAuthorization( ps.getProjectGroup().getName() );

        List<BuildResultSummary> result = new ArrayList<BuildResultSummary>();
        Collection<org.apache.maven.continuum.model.project.BuildResult> buildResults =
            continuum.getBuildResultsForProject( projectId );
        if ( buildResults != null )
        {
            for ( org.apache.maven.continuum.model.project.BuildResult buildResult : buildResults )
            {
                BuildResultSummary br = populateBuildResultSummary( buildResult );
                result.add( br );
            }
        }

        return result;
    }

    public int removeBuildResult( BuildResult br )
        throws ContinuumException
    {
        checkModifyProjectGroupAuthorization( getProjectSummary(
            br.getProject().getId() ).getProjectGroup().getName() );
        continuum.removeBuildResult( br.getId() );
        return 0;
    }

    public String getBuildOutput( int projectId, int buildId )
        throws ContinuumException
    {
        ProjectSummary ps = getProjectSummary( projectId );
        checkViewProjectGroupAuthorization( ps.getProjectGroup().getName() );

        return continuum.getBuildOutput( projectId, buildId );
    }

    // ----------------------------------------------------------------------
    // Maven 2.x projects
    // ----------------------------------------------------------------------

    public AddingResult addMavenTwoProject( String url )
        throws ContinuumException
    {
        checkAddProjectGroupAuthorization();

        ContinuumProjectBuildingResult result = continuum.addMavenTwoProject( url );
        return populateAddingResult( result );
    }

    public AddingResult addMavenTwoProject( String url, int projectGroupId )
        throws ContinuumException
    {
        checkAddProjectAuthorization( projectGroupId );

        ContinuumProjectBuildingResult result = continuum.addMavenTwoProject( url, projectGroupId );
        return populateAddingResult( result );
    }

    public AddingResult addMavenTwoProject( String url, int projectGroupId, boolean checkoutInSingleDirectory )
        throws ContinuumException
    {
        checkAddProjectAuthorization( projectGroupId );

        ContinuumProjectBuildingResult result;
        try
        {
            result = continuum.addMavenTwoProject( url, projectGroupId, true, // checkProtocol
                                                   false, // useCredentialsCache
                                                   true, // recursiveProjects
                                                   continuum.getBuildDefinitionService().getDefaultMavenTwoBuildDefinitionTemplate().getId(),
                                                   checkoutInSingleDirectory );
        }
        catch ( BuildDefinitionServiceException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }

        return populateAddingResult( result );
    }

    public AddingResult addMavenTwoProjectAsSingleProject( String url, int projectGroupId )
        throws Exception
    {
        checkAddProjectAuthorization( projectGroupId );

        ContinuumProjectBuildingResult result;
        try
        {
            result = continuum.addMavenTwoProject( url, projectGroupId, true, // checkProtocol
                                                   false, // useCredentialsCache
                                                   false, // recursiveProjects
                                                   continuum.getBuildDefinitionService().getDefaultMavenTwoBuildDefinitionTemplate().getId(),
                                                   true ); // a multi-module project added as a single project is always
            // checked out
            // in a single directory, regardless the value set for
            // checkoutInSingleDirectory
            // variable
        }
        catch ( BuildDefinitionServiceException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }

        return populateAddingResult( result );
    }

    private void checkAddProjectAuthorization( int projectGroupId )
        throws ContinuumException
    {
        if ( projectGroupId == -1 )
        {
            checkAuthorization( ContinuumRoleConstants.CONTINUUM_ADD_GROUP_OPERATION );
        }
        else
        {
            checkAuthorization( ContinuumRoleConstants.CONTINUUM_ADD_PROJECT_TO_GROUP_OPERATION, getProjectGroupName(
                projectGroupId ) );
        }
    }

    public AddingResult addMavenTwoProject( String url, int projectGroupId, boolean checkProtocol,
                                            boolean useCredentialsCache, boolean recursiveProjects,
                                            boolean checkoutInSingleDirectory )
        throws Exception
    {
        checkAddProjectAuthorization( projectGroupId );

        ContinuumProjectBuildingResult result;
        try
        {
            result = continuum.addMavenTwoProject( url, projectGroupId, checkProtocol, useCredentialsCache,
                                                   recursiveProjects,
                                                   continuum.getBuildDefinitionService().getDefaultMavenTwoBuildDefinitionTemplate().getId(),
                                                   checkoutInSingleDirectory );
        }
        catch ( BuildDefinitionServiceException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }

        return populateAddingResult( result );
    }

    // ----------------------------------------------------------------------
    // Maven 1.x projects
    // ----------------------------------------------------------------------

    public AddingResult addMavenOneProject( String url, int projectGroupId )
        throws ContinuumException
    {
        checkAddProjectAuthorization( projectGroupId );

        ContinuumProjectBuildingResult result = continuum.addMavenOneProject( url, projectGroupId );
        return populateAddingResult( result );
    }

    // ----------------------------------------------------------------------
    // Maven ANT projects
    // ----------------------------------------------------------------------

    public ProjectSummary addAntProject( ProjectSummary project, int projectGroupId )
        throws ContinuumException
    {
        checkAddProjectGroupAuthorization();
        org.apache.maven.continuum.model.project.Project newProject =
            new org.apache.maven.continuum.model.project.Project();
        int projectId = continuum.addProject( populateProject( project, newProject ),
                                              ContinuumBuildExecutorConstants.ANT_BUILD_EXECUTOR, projectGroupId );
        return getProjectSummary( projectId );
    }

    // ----------------------------------------------------------------------
    // Maven Shell projects
    // ----------------------------------------------------------------------

    public ProjectSummary addShellProject( ProjectSummary project, int projectGroupId )
        throws ContinuumException
    {
        checkAddProjectGroupAuthorization();
        org.apache.maven.continuum.model.project.Project newProject =
            new org.apache.maven.continuum.model.project.Project();
        int projectId = continuum.addProject( populateProject( project, newProject ),
                                              ContinuumBuildExecutorConstants.SHELL_BUILD_EXECUTOR, projectGroupId );
        return getProjectSummary( projectId );
    }

    // ----------------------------------------------------------------------
    // Schedules
    // ----------------------------------------------------------------------

    public List<Schedule> getSchedules()
        throws ContinuumException
    {
        checkManageSchedulesAuthorization();
        Collection schedules = continuum.getSchedules();

        List<Schedule> s = new ArrayList<Schedule>();
        for ( Object schedule : schedules )
        {
            s.add( populateSchedule( (org.apache.maven.continuum.model.project.Schedule) schedule ) );
        }

        return s;
    }

    public Schedule getSchedule( int scheduleId )
        throws ContinuumException
    {
        checkManageSchedulesAuthorization();
        return populateSchedule( continuum.getSchedule( scheduleId ) );
    }

    public Schedule updateSchedule( Schedule schedule )
        throws ContinuumException
    {
        checkManageSchedulesAuthorization();
        org.apache.maven.continuum.model.project.Schedule s = continuum.getSchedule( schedule.getId() );
        org.apache.maven.continuum.model.project.Schedule newSchedule = populateSchedule( schedule, s );
        org.apache.maven.continuum.model.project.Schedule storedSchedule = continuum.getSchedule( schedule.getId() );
        storedSchedule.setActive( newSchedule.isActive() );
        storedSchedule.setName( newSchedule.getName() );
        storedSchedule.setDescription( StringEscapeUtils.escapeXml( newSchedule.getDescription() ) );
        storedSchedule.setDelay( newSchedule.getDelay() );
        storedSchedule.setCronExpression( newSchedule.getCronExpression() );
        storedSchedule.setMaxJobExecutionTime( newSchedule.getMaxJobExecutionTime() );
        continuum.updateSchedule( storedSchedule );

        return populateSchedule( continuum.getScheduleByName( schedule.getName() ) );
    }

    public Schedule addSchedule( Schedule schedule )
        throws ContinuumException
    {
        checkManageSchedulesAuthorization();
        org.apache.maven.continuum.model.project.Schedule s = new org.apache.maven.continuum.model.project.Schedule();
        continuum.addSchedule( populateSchedule( schedule, s ) );

        return populateSchedule( continuum.getScheduleByName( schedule.getName() ) );
    }

    // ----------------------------------------------------------------------
    // Profiles
    // ----------------------------------------------------------------------

    public List<Profile> getProfiles()
        throws ContinuumException
    {
        checkManageProfilesAuthorization();
        Collection profiles = continuum.getProfileService().getAllProfiles();

        List<Profile> p = new ArrayList<Profile>();
        for ( Object profile : profiles )
        {
            p.add( populateProfile( (org.apache.maven.continuum.model.system.Profile) profile ) );
        }

        return p;
    }

    public Profile getProfile( int profileId )
        throws ContinuumException
    {
        checkManageProfilesAuthorization();
        return populateProfile( continuum.getProfileService().getProfile( profileId ) );
    }

    public Profile getProfileWithName( String profileName )
        throws ContinuumException
    {
        checkManageProfilesAuthorization();
        org.apache.maven.continuum.model.system.Profile profile = continuum.getProfileService().getProfileWithName(
            profileName );
        return profile != null ? populateProfile( profile ) : null;
    }

    public Profile addProfile( Profile profile )
        throws ContinuumException
    {
        org.apache.maven.continuum.model.system.Profile newProfile =
            new org.apache.maven.continuum.model.system.Profile();

        return populateProfile( continuum.getProfileService().addProfile( populateProfile( profile, newProfile ) ) );
    }

    public int updateProfile( Profile profile )
        throws ContinuumException
    {
        org.apache.maven.continuum.model.system.Profile newProfile = continuum.getProfileService().getProfile(
            profile.getId() );

        continuum.getProfileService().updateProfile( populateProfile( profile, newProfile ) );
        return 0;
    }

    public int deleteProfile( int profileId )
        throws ContinuumException
    {

        continuum.getProfileService().deleteProfile( profileId );
        return 0;
    }

    // ----------------------------------------------------------------------
    // Installations
    // ----------------------------------------------------------------------

    public List<Installation> getInstallations()
        throws ContinuumException
    {
        checkManageInstallationsAuthorization();
        try
        {
            List<org.apache.maven.continuum.model.system.Installation> installs =
                continuum.getInstallationService().getAllInstallations();

            List<Installation> i = new ArrayList<Installation>();
            for ( Object install : installs )
            {
                i.add( populateInstallation( (org.apache.maven.continuum.model.system.Installation) install ) );
            }
            return i;
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't load installations", e );
        }
    }

    public List<Installation> getBuildAgentInstallations( String url )
        throws ContinuumException
    {
        try
        {
            List<org.apache.maven.continuum.model.system.Installation> buildAgentInstallations =
                distributedBuildManager.getAvailableInstallations( url );

            List<Installation> convertedBuildAgentInstallations = new ArrayList<Installation>();
            for ( Object buildAgentInstallation : buildAgentInstallations )
            {
                convertedBuildAgentInstallations.add( populateInstallation(
                    (org.apache.maven.continuum.model.system.Installation) buildAgentInstallation ) );
            }
            return convertedBuildAgentInstallations;
        }
        catch ( Exception e )
        {
            throw new ContinuumException( "Can't load installations", e );
        }
    }

    public Installation getInstallation( int installationId )
        throws ContinuumException
    {
        checkManageInstallationsAuthorization();
        try
        {
            org.apache.maven.continuum.model.system.Installation install =
                continuum.getInstallationService().getInstallation( installationId );
            return populateInstallation( install );
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't load installations", e );
        }
    }

    public Installation getInstallation( String installationName )
        throws ContinuumException
    {
        checkManageInstallationsAuthorization();
        try
        {
            org.apache.maven.continuum.model.system.Installation install =
                continuum.getInstallationService().getInstallation( installationName );
            return install != null ? populateInstallation( install ) : null;
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't load installations", e );
        }
    }

    public Installation addInstallation( Installation installation )
        throws ContinuumException
    {
        try
        {
            org.apache.maven.continuum.model.system.Installation newInstallation =
                new org.apache.maven.continuum.model.system.Installation();
            return populateInstallation( continuum.getInstallationService().add( populateInstallation( installation,
                                                                                                       newInstallation ) ) );
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't delete installations", e );
        }
    }

    public int updateInstallation( Installation installation )
        throws ContinuumException
    {
        try
        {
            final org.apache.maven.continuum.model.system.Installation newInst =
                continuum.getInstallationService().getInstallation( installation.getInstallationId() );
            continuum.getInstallationService().update( populateInstallation( installation, newInst ) );
            return 0;
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't delete installations", e );
        }
    }

    public int deleteInstallation( int installationId )
        throws ContinuumException
    {
        try
        {
            org.apache.maven.continuum.model.system.Installation installationTODelete =
                continuum.getInstallationService().getInstallation( installationId );
            continuum.getInstallationService().delete( installationTODelete );
            return 0;
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't delete installations", e );
        }
    }

    // ----------------------------------------------------------------------
    // SystemConfigurationDao
    // ----------------------------------------------------------------------

    public SystemConfiguration getSystemConfiguration()
        throws ContinuumException
    {
        checkManageConfigurationAuthorization();
        try
        {
            org.apache.maven.continuum.model.system.SystemConfiguration sysConf =
                systemConfigurationDao.getSystemConfiguration();
            return populateSystemConfiguration( sysConf );
        }
        catch ( ContinuumStoreException e )
        {
            throw new ContinuumException( "Can't get SystemConfigurationDao.", e );
        }
    }

    // ----------------------------------------------------------------------
    // Queue
    // ----------------------------------------------------------------------
    public boolean isProjectInPrepareBuildQueue( int projectId )
        throws ContinuumException
    {
        return isProjectInPrepareBuildQueue( projectId, -1 );
    }

    public boolean isProjectInPrepareBuildQueue( int projectId, int buildDefinitionId )
        throws ContinuumException
    {
        try
        {
            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                return distributedBuildManager.isProjectInAnyPrepareBuildQueue( projectId, buildDefinitionId );
            }
            else
            {
                return parallelBuildsManager.isInPrepareBuildQueue( projectId );
            }
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    public boolean isProjectInBuildingQueue( int projectId )
        throws ContinuumException
    {
        return isProjectInBuildingQueue( projectId, -1 );
    }

    public boolean isProjectInBuildingQueue( int projectId, int buildDefinitionId )
        throws ContinuumException
    {
        try
        {
            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                return distributedBuildManager.isProjectInAnyBuildQueue( projectId, buildDefinitionId );
            }
            else
            {
                return parallelBuildsManager.isInAnyBuildQueue( projectId );
            }
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    public boolean isProjectCurrentlyPreparingBuild( int projectId )
        throws ContinuumException
    {
        return isProjectCurrentlyPreparingBuild( projectId, -1 );
    }

    public boolean isProjectCurrentlyPreparingBuild( int projectId, int buildDefinitionId )
        throws ContinuumException
    {
        try
        {
            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                return distributedBuildManager.isProjectCurrentlyPreparingBuild( projectId, buildDefinitionId );
            }
            else
            {
                return parallelBuildsManager.isProjectCurrentlyPreparingBuild( projectId );
            }
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    public boolean isProjectCurrentlyBuilding( int projectId )
        throws ContinuumException
    {
        return isProjectCurrentlyBuilding( projectId, -1 );
    }

    public boolean isProjectCurrentlyBuilding( int projectId, int buildDefinitionId )
        throws ContinuumException
    {
        try
        {
            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                return distributedBuildManager.isProjectCurrentlyBuilding( projectId, buildDefinitionId );
            }
            else
            {
                return parallelBuildsManager.isProjectInAnyCurrentBuild( projectId );
            }
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    public List<BuildProjectTask> getProjectsInBuildQueue()
        throws ContinuumException
    {
        try
        {
            Map<String, List<org.apache.continuum.taskqueue.BuildProjectTask>> buildTasks;

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                buildTasks = distributedBuildManager.getProjectsInBuildQueue();
            }
            else
            {
                buildTasks = parallelBuildsManager.getProjectsInBuildQueues();
            }

            Set<String> keys = buildTasks.keySet();
            List<org.apache.continuum.taskqueue.BuildProjectTask> convertedTasks =
                new ArrayList<org.apache.continuum.taskqueue.BuildProjectTask>();

            for ( String key : keys )
            {
                List<org.apache.continuum.taskqueue.BuildProjectTask> tasks = buildTasks.get( key );
                for ( org.apache.continuum.taskqueue.BuildProjectTask task : tasks )
                {
                    convertedTasks.add( task );
                }
            }

            return populateBuildProjectTaskList( convertedTasks );
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    public int removeProjectsFromBuildingQueue( int[] projectsId )
        throws ContinuumException
    {
        checkManageQueuesAuthorization();

        parallelBuildsManager.removeProjectsFromBuildQueue( projectsId );

        return 0;
    }

    public boolean cancelCurrentBuild()
        throws ContinuumException
    {
        checkManageQueuesAuthorization();
        try
        {
            return parallelBuildsManager.cancelAllBuilds();
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    public boolean cancelBuild( int projectId, int buildDefinitionId )
        throws ContinuumException
    {
        checkManageQueuesAuthorization();
        try
        {
            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                DistributedBuildManager dbm = continuum.getDistributedBuildManager();

                String buildAgentUrl = dbm.getBuildAgentUrl( projectId, buildDefinitionId );

                if ( dbm.isProjectInAnyPrepareBuildQueue( projectId, buildDefinitionId ) )
                {
                    if ( buildAgentUrl != null )
                    {
                        org.apache.continuum.model.project.ProjectScmRoot scmRoot =
                            continuum.getProjectScmRootByProject( projectId );
                        dbm.removeFromPrepareBuildQueue( buildAgentUrl, scmRoot.getProjectGroup().getId(),
                                                         scmRoot.getId() );
                    }
                }
                // wait if already preparing
                else if ( dbm.isProjectCurrentlyPreparingBuild( projectId, buildDefinitionId ) )
                {
                    while ( dbm.isProjectCurrentlyPreparingBuild( projectId, buildDefinitionId ) )
                    {
                        try
                        {
                            Thread.sleep( 1000 );
                        }
                        catch ( InterruptedException e )
                        {
                            // do nothing
                        }
                    }
                }

                if ( dbm.isProjectInAnyBuildQueue( projectId, buildDefinitionId ) )
                {
                    dbm.removeFromBuildQueue( buildAgentUrl, projectId, buildDefinitionId );
                }
                else if ( dbm.isProjectCurrentlyBuilding( projectId, buildDefinitionId ) )
                {
                    if ( buildAgentUrl != null )
                    {
                        dbm.cancelDistributedBuild( buildAgentUrl );
                    }
                }

                return true;
            }
            else
            {
                // if currently preparing build or being checked out, wait until done
                if ( parallelBuildsManager.isProjectCurrentlyPreparingBuild( projectId ) ||
                    parallelBuildsManager.isProjectCurrentlyBeingCheckedOut( projectId ) )
                {
                    while ( parallelBuildsManager.isProjectCurrentlyPreparingBuild( projectId ) ||
                        parallelBuildsManager.isProjectCurrentlyBeingCheckedOut( projectId ) )
                    {
                        try
                        {
                            Thread.sleep( 1000 );
                        }
                        catch ( InterruptedException e )
                        {
                            // do nothing
                        }
                    }
                }

                if ( parallelBuildsManager.isInPrepareBuildQueue( projectId ) )
                {
                    org.apache.continuum.model.project.ProjectScmRoot scmRoot = continuum.getProjectScmRootByProject(
                        projectId );
                    parallelBuildsManager.removeProjectFromPrepareBuildQueue( scmRoot.getProjectGroup().getId(),
                                                                              scmRoot.getId() );
                }
                else if ( parallelBuildsManager.isInAnyCheckoutQueue( projectId ) )
                {
                    parallelBuildsManager.removeProjectFromCheckoutQueue( projectId );
                }
                else if ( parallelBuildsManager.isInAnyBuildQueue( projectId ) )
                {
                    parallelBuildsManager.removeProjectFromBuildQueue( projectId );
                }
                else if ( parallelBuildsManager.isProjectInAnyCurrentBuild( projectId ) )
                {
                    return parallelBuildsManager.cancelBuild( projectId );
                }

                return true;
            }
        }
        catch ( BuildManagerException e )
        {
            throw new ContinuumException( e.getMessage(), e );
        }
    }

    // ----------------------------------------------------------------------
    // Release Results
    // ----------------------------------------------------------------------

    public ContinuumReleaseResult getReleaseResult( int releaseId )
        throws ContinuumException
    {
        org.apache.continuum.model.release.ContinuumReleaseResult releaseResult = continuum.getContinuumReleaseResult(
            releaseId );
        checkViewProjectGroupAuthorization( getProjectGroupName( releaseResult.getProjectGroup().getId() ) );
        return populateReleaseResult( releaseResult );
    }

    public List<ContinuumReleaseResult> getReleaseResultsForProjectGroup( int projectGroupId )
        throws ContinuumException
    {
        checkViewProjectGroupAuthorization( getProjectGroupName( projectGroupId ) );
        Collection releaseResults = continuum.getContinuumReleaseResultsByProjectGroup( projectGroupId );

        List<ContinuumReleaseResult> r = new ArrayList<ContinuumReleaseResult>();
        for ( Object releaseResult : releaseResults )
        {
            r.add( populateReleaseResult( (org.apache.continuum.model.release.ContinuumReleaseResult) releaseResult ) );
        }
        return r;
    }

    public int removeReleaseResult( ContinuumReleaseResult releaseResult )
        throws ContinuumException
    {
        checkModifyProjectGroupAuthorization( getProjectGroupName( releaseResult.getProjectGroup().getId() ) );
        continuum.removeContinuumReleaseResult( releaseResult.getId() );
        return 0;
    }

    public String getReleaseOutput( int releaseId )
        throws ContinuumException
    {
        org.apache.continuum.model.release.ContinuumReleaseResult releaseResult = continuum.getContinuumReleaseResult(
            releaseId );
        checkViewProjectGroupAuthorization( getProjectGroupName( releaseResult.getProjectGroup().getId() ) );

        return continuum.getReleaseOutput( releaseId );
    }

    // ----------------------------------------------------------------------
    // Purge Configuration
    // ----------------------------------------------------------------------

    public RepositoryPurgeConfiguration addRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.RepositoryPurgeConfiguration newPurge =
                new org.apache.continuum.model.repository.RepositoryPurgeConfiguration();
            return populateRepositoryPurgeConfiguration(
                continuum.getPurgeConfigurationService().addRepositoryPurgeConfiguration(
                    populateRepositoryPurgeConfiguration( repoPurge, newPurge ) )
            );
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Error while converting repository purge configuration", e );
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Can't add repositoryPurgeConfiguration", e );
        }
    }

    public int updateRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.RepositoryPurgeConfiguration purge =
                new org.apache.continuum.model.repository.RepositoryPurgeConfiguration();
            continuum.getPurgeConfigurationService().updateRepositoryPurgeConfiguration(
                populateRepositoryPurgeConfiguration( repoPurge, purge ) );
            return 0;
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Error while converting repository purge configuration", e );
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Cant' update repository PurgeException", e );
        }
    }

    public int removeRepositoryPurgeConfiguration( int repoPurgeId )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.RepositoryPurgeConfiguration repoPurge =
                continuum.getPurgeConfigurationService().getRepositoryPurgeConfiguration( repoPurgeId );
            continuum.getPurgeConfigurationService().removeRepositoryPurgeConfiguration( repoPurge );
            return 0;
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Can't delete repository purge configuration", e );
        }
    }

    public RepositoryPurgeConfiguration getRepositoryPurgeConfiguration( int repoPurgeId )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.RepositoryPurgeConfiguration repoPurgeConfig =
                continuum.getPurgeConfigurationService().getRepositoryPurgeConfiguration( repoPurgeId );
            return populateRepositoryPurgeConfiguration( repoPurgeConfig );
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Error while retrieving repository purge configuration", e );
        }
    }

    public List<RepositoryPurgeConfiguration> getAllRepositoryPurgeConfigurations()
        throws ContinuumException
    {
        checkManagePurgingAuthorization();
        Collection repoPurgeConfigs = continuum.getPurgeConfigurationService().getAllRepositoryPurgeConfigurations();

        List<RepositoryPurgeConfiguration> r = new ArrayList<RepositoryPurgeConfiguration>();
        for ( Object repoPurgeConfig : repoPurgeConfigs )
        {
            r.add( populateRepositoryPurgeConfiguration(
                (org.apache.continuum.model.repository.RepositoryPurgeConfiguration) repoPurgeConfig ) );
        }
        return r;
    }

    public DirectoryPurgeConfiguration addDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.DirectoryPurgeConfiguration newPurge =
                new org.apache.continuum.model.repository.DirectoryPurgeConfiguration();
            return populateDirectoryPurgeConfiguration(
                continuum.getPurgeConfigurationService().addDirectoryPurgeConfiguration(
                    populateDirectoryPurgeConfiguration( dirPurge, newPurge ) )
            );
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Error while converting directory purge configuration", e );
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Can't add directory purge configuration", e );
        }
    }

    public int updateDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.DirectoryPurgeConfiguration purge =
                new org.apache.continuum.model.repository.DirectoryPurgeConfiguration();
            continuum.getPurgeConfigurationService().updateDirectoryPurgeConfiguration(
                populateDirectoryPurgeConfiguration( dirPurge, purge ) );
            return 0;
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Error while converting directory purge configuration", e );
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Can't add directory purge configuration", e );
        }
    }

    public int removeDirectoryPurgeConfiguration( int dirPurgeId )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.DirectoryPurgeConfiguration dirPurge =
                continuum.getPurgeConfigurationService().getDirectoryPurgeConfiguration( dirPurgeId );
            continuum.getPurgeConfigurationService().removeDirectoryPurgeConfiguration( dirPurge );
            return 0;
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Can't delete directory purge configuration", e );
        }
    }

    public DirectoryPurgeConfiguration getDirectoryPurgeConfiguration( int dirPurgeId )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.DirectoryPurgeConfiguration dirPurgeConfig =
                continuum.getPurgeConfigurationService().getDirectoryPurgeConfiguration( dirPurgeId );
            return populateDirectoryPurgeConfiguration( dirPurgeConfig );
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Error while retrieving directory purge configuration", e );
        }
    }

    public List<DirectoryPurgeConfiguration> getAllDirectoryPurgeConfigurations()
        throws ContinuumException
    {
        checkManagePurgingAuthorization();
        Collection dirPurgeConfigs = continuum.getPurgeConfigurationService().getAllDirectoryPurgeConfigurations();

        List<DirectoryPurgeConfiguration> d = new ArrayList<DirectoryPurgeConfiguration>();
        for ( Object dirPurgeConfig : dirPurgeConfigs )
        {
            d.add( populateDirectoryPurgeConfiguration(
                (org.apache.continuum.model.repository.DirectoryPurgeConfiguration) dirPurgeConfig ) );
        }
        return d;
    }

    public int purgeLocalRepository( int repoPurgeId )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.RepositoryPurgeConfiguration repoPurgeConfig =
                continuum.getPurgeConfigurationService().getRepositoryPurgeConfiguration( repoPurgeId );
            continuum.getPurgeManager().purgeRepository( repoPurgeConfig );

            return 0;
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Error while retrieving repository purge configuration", e );
        }
        catch ( ContinuumPurgeManagerException e )
        {
            throw new ContinuumException( "Error while purging local repository", e );
        }
    }

    public int purgeDirectory( int dirPurgeId )
        throws ContinuumException
    {
        checkManagePurgingAuthorization();

        try
        {
            org.apache.continuum.model.repository.DirectoryPurgeConfiguration dirPurgeConfig =
                continuum.getPurgeConfigurationService().getDirectoryPurgeConfiguration( dirPurgeId );
            continuum.getPurgeManager().purgeDirectory( dirPurgeConfig );

            return 0;
        }
        catch ( PurgeConfigurationServiceException e )
        {
            throw new ContinuumException( "Error while retrieving directory purge configuration", e );
        }
        catch ( ContinuumPurgeManagerException e )
        {
            throw new ContinuumException( "Error while purging directory", e );
        }
    }

    // ----------------------------------------------------------------------
    // Local Repository
    // ----------------------------------------------------------------------

    public LocalRepository addLocalRepository( LocalRepository repository )
        throws ContinuumException
    {
        checkManageRepositoriesAuthorization();

        try
        {
            org.apache.continuum.model.repository.LocalRepository newRepository =
                new org.apache.continuum.model.repository.LocalRepository();
            return populateLocalRepository( continuum.getRepositoryService().addLocalRepository(
                populateLocalRepository( repository, newRepository ) ) );
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Unable to add repository", e );
        }
    }

    public int updateLocalRepository( LocalRepository repository )
        throws ContinuumException
    {
        checkManageRepositoriesAuthorization();

        try
        {
            final org.apache.continuum.model.repository.LocalRepository newRepo =
                continuum.getRepositoryService().getLocalRepository( repository.getId() );
            continuum.getRepositoryService().updateLocalRepository( populateLocalRepository( repository, newRepo ) );
            return 0;
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Can't update repository", e );
        }
    }

    public int removeLocalRepository( int repositoryId )
        throws ContinuumException
    {
        checkManageRepositoriesAuthorization();

        try
        {
            continuum.getRepositoryService().removeLocalRepository( repositoryId );
            return 0;
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Can't delete repository", e );
        }
    }

    public LocalRepository getLocalRepository( int repositoryId )
        throws ContinuumException
    {
        checkManageRepositoriesAuthorization();

        try
        {
            return populateLocalRepository( continuum.getRepositoryService().getLocalRepository( repositoryId ) );
        }
        catch ( RepositoryServiceException e )
        {
            throw new ContinuumException( "Error while retrieving repository.", e );
        }
    }

    public List<LocalRepository> getAllLocalRepositories()
        throws ContinuumException
    {
        checkManageRepositoriesAuthorization();
        Collection repos = continuum.getRepositoryService().getAllLocalRepositories();

        List<LocalRepository> r = new ArrayList<LocalRepository>();
        for ( Object repo : repos )
        {
            r.add( populateLocalRepository( (org.apache.continuum.model.repository.LocalRepository) repo ) );
        }
        return r;
    }

    // ----------------------------------------------------------------------
    // Build agent
    // ----------------------------------------------------------------------

    public BuildAgentConfiguration addBuildAgent( BuildAgentConfiguration buildAgentConfiguration )
        throws ConfigurationException, ConfigurationStoringException, ContinuumConfigurationException
    {
        ConfigurationService configurationService = continuum.getConfiguration();

        if ( buildAgentConfiguration == null )
        {
            return null;
        }
        try
        {
            configurationService.addBuildAgent( populateBuildAgent( buildAgentConfiguration ) );
            configurationService.store();
            return populateBuildAgent( configurationService.getBuildAgent( buildAgentConfiguration.getUrl() ) );
        }
        catch ( ContinuumException e )
        {
            throw new ConfigurationException( "Error in adding buildAgent", e );
        }
    }

    public BuildAgentConfiguration getBuildAgent( String url )
    {
        ConfigurationService configurationService = continuum.getConfiguration();
        org.apache.continuum.configuration.BuildAgentConfiguration buildAgent = configurationService.getBuildAgent(
            url );
        return buildAgent != null ? populateBuildAgent( buildAgent ) : null;
    }

    /**
     * {@inheritDoc}
     *
     * @throws ContinuumException distributed build is not enabled or error during retrieval of build agent url
     * @see DistributedBuildManager#getBuildAgentUrl(int, int)
     */
    public String getBuildAgentUrl( int projectId, int buildDefinitionId )
        throws ContinuumException
    {
        if ( !continuum.getConfiguration().isDistributedBuildEnabled() )
        {
            throw new ContinuumException( "Method available only in distributed build mode." );
        }

        return distributedBuildManager.getBuildAgentUrl( projectId, buildDefinitionId );
    }

    public BuildAgentConfiguration updateBuildAgent( BuildAgentConfiguration buildAgentConfiguration )
        throws ConfigurationStoringException, ContinuumConfigurationException
    {
        try
        {
            ConfigurationService configurationService = continuum.getConfiguration();
            org.apache.continuum.configuration.BuildAgentConfiguration buildAgent = configurationService.getBuildAgent(
                buildAgentConfiguration.getUrl() );
            BuildAgentConfiguration buildAgentConfigurationToUpdate = buildAgent != null ? populateBuildAgent(
                buildAgent ) : null;

            if ( buildAgentConfigurationToUpdate != null )
            {
                buildAgentConfigurationToUpdate.setDescription( StringEscapeUtils.escapeXml(
                    buildAgentConfiguration.getDescription() ) );
                buildAgentConfigurationToUpdate.setEnabled( buildAgentConfiguration.isEnabled() );
                configurationService.updateBuildAgent( populateBuildAgent( buildAgentConfigurationToUpdate ) );
                configurationService.store();
                return populateBuildAgent( configurationService.getBuildAgent( buildAgentConfiguration.getUrl() ) );
            }
            else
            {
                return null;
            }
        }
        catch ( ContinuumException e )
        {
            throw new ContinuumConfigurationException( "Error in adding buildAgent", e );
        }
    }

    public boolean removeBuildAgent( String url )
        throws BuildAgentConfigurationException, ConfigurationStoringException, ContinuumConfigurationException,
        ContinuumException
    {
        ConfigurationService configurationService = continuum.getConfiguration();

        boolean SUCCESS;
        org.apache.continuum.configuration.BuildAgentConfiguration buildAgent = configurationService.getBuildAgent(
            url );
        BuildAgentConfiguration buildAgentConfiguration = buildAgent != null ? populateBuildAgent( buildAgent ) : null;
        if ( buildAgentConfiguration != null )
        {
            if ( continuum.getDistributedBuildManager().isBuildAgentBusy( buildAgentConfiguration.getUrl() ) )
            {
                throw new BuildAgentConfigurationException(
                    "Cannot delete build agent because it's busy at the moment" );
            }

            if ( configurationService.getBuildAgentGroups() != null )
            {
                for ( org.apache.continuum.configuration.BuildAgentGroupConfiguration buildAgentGroup : configurationService.getBuildAgentGroups() )
                {
                    if ( configurationService.containsBuildAgentUrl( buildAgentConfiguration.getUrl(),
                                                                     buildAgentGroup ) )
                    {
                        throw new BuildAgentConfigurationException(
                            "Cannot delete build agent because it's in use at the moment" );
                    }
                }
            }

            try
            {
                continuum.getDistributedBuildManager().removeDistributedBuildQueueOfAgent(
                    buildAgentConfiguration.getUrl() );
                configurationService.removeBuildAgent( populateBuildAgent( buildAgentConfiguration ) );
                configurationService.store();
                SUCCESS = true;
            }
            catch ( ContinuumException e )
            {
                throw new ContinuumException( "Error when removing build agent in build queue", e );
            }

        }
        else
        {
            throw new BuildAgentConfigurationException( "Build agent does not exist." );
        }

        return SUCCESS;
    }

    public List<BuildAgentConfiguration> getAllBuildAgents()
    {
        ConfigurationService configurationService = continuum.getConfiguration();

        List<org.apache.continuum.configuration.BuildAgentConfiguration> buildAgents =
            configurationService.getBuildAgents();
        List<BuildAgentConfiguration> buildAgentConfigurations = new ArrayList<BuildAgentConfiguration>();

        if ( buildAgents != null )
        {
            for ( org.apache.continuum.configuration.BuildAgentConfiguration buildAgent : buildAgents )
            {
                buildAgentConfigurations.add( populateBuildAgent( buildAgent ) );
            }
        }
        return buildAgentConfigurations;
    }

    public List<BuildAgentConfiguration> getBuildAgentsWithInstallations()
        throws Exception
    {
        ConfigurationService configurationService = continuum.getConfiguration();

        List<org.apache.continuum.configuration.BuildAgentConfiguration> buildAgents =
            configurationService.getBuildAgents();
        List<BuildAgentConfiguration> buildAgentConfigurations = new ArrayList<BuildAgentConfiguration>();

        if ( buildAgents != null )
        {
            for ( org.apache.continuum.configuration.BuildAgentConfiguration buildAgent : buildAgents )
            {
                if ( buildAgent.isEnabled() )
                {
                    BuildAgentConfiguration agent = populateBuildAgent( buildAgent );
                    agent.setInstallations( getBuildAgentInstallations( buildAgent.getUrl() ) );
                    buildAgentConfigurations.add( agent );
                }
            }
        }
        return buildAgentConfigurations;
    }

    // ----------------------------------------------------------------------
    // Build agent group
    // ----------------------------------------------------------------------

    public BuildAgentGroupConfiguration addBuildAgentGroup( BuildAgentGroupConfiguration buildAgentGroup )
        throws ConfigurationException, ConfigurationStoringException, ContinuumConfigurationException
    {
        ConfigurationService configurationService = continuum.getConfiguration();

        if ( buildAgentGroup == null )
        {
            return null;
        }
        try
        {
            configurationService.addBuildAgentGroup( populateBuildAgentGroup( buildAgentGroup ) );
            configurationService.store();
            return populateBuildAgentGroup( configurationService.getBuildAgentGroup( buildAgentGroup.getName() ) );
        }
        catch ( ContinuumException e )
        {
            throw new ConfigurationException( "Error in adding buildAgentGroup", e );
        }
    }

    public BuildAgentGroupConfiguration getBuildAgentGroup( String name )
    {
        ConfigurationService configurationService = continuum.getConfiguration();
        org.apache.continuum.configuration.BuildAgentGroupConfiguration buildAgentGroup =
            configurationService.getBuildAgentGroup( name );
        return buildAgentGroup != null ? populateBuildAgentGroup( buildAgentGroup ) : null;
    }

    public BuildAgentGroupConfiguration updateBuildAgentGroup( BuildAgentGroupConfiguration buildAgentGroup )
        throws ConfigurationException, ConfigurationStoringException, ContinuumConfigurationException
    {
        try
        {
            ConfigurationService configurationService = continuum.getConfiguration();
            org.apache.continuum.configuration.BuildAgentGroupConfiguration buildAgentGroupConfiguration =
                configurationService.getBuildAgentGroup( buildAgentGroup.getName() );

            if ( buildAgentGroupConfiguration != null )
            {
                buildAgentGroupConfiguration.setName( StringEscapeUtils.escapeXml( buildAgentGroup.getName() ) );
                if ( buildAgentGroup.getBuildAgents() != null )
                {
                    buildAgentGroupConfiguration.getBuildAgents().clear();
                    for ( BuildAgentConfiguration buildAgent : buildAgentGroup.getBuildAgents() )
                    {
                        buildAgentGroupConfiguration.getBuildAgents().add( populateBuildAgent( buildAgent ) );
                    }
                }
                else
                {
                    buildAgentGroupConfiguration.setBuildAgents( null );
                }
                configurationService.updateBuildAgentGroup( buildAgentGroupConfiguration );
                configurationService.store();
                return populateBuildAgentGroup( configurationService.getBuildAgentGroup( buildAgentGroup.getName() ) );
            }
            else
            {
                return null;
            }
        }
        catch ( ContinuumException e )
        {
            throw new ContinuumConfigurationException(
                "Error in updating build agent group " + buildAgentGroup.getName(), e );
        }
    }

    public int removeBuildAgentGroup( String name )
        throws ConfigurationException
    {
        ConfigurationService configurationService = continuum.getConfiguration();
        org.apache.continuum.configuration.BuildAgentGroupConfiguration buildAgentGroupConfiguration =
            configurationService.getBuildAgentGroup( name );
        if ( buildAgentGroupConfiguration != null )
        {
            configurationService.removeBuildAgentGroup( buildAgentGroupConfiguration );
        }

        return 0;
    }

    // ----------------------------------------------------------------------
    // Converters
    // ----------------------------------------------------------------------

    private List<BuildProjectTask> populateBuildProjectTaskList(
        List<org.apache.continuum.taskqueue.BuildProjectTask> buildProjectTasks )
    {
        List<BuildProjectTask> responses = new ArrayList<BuildProjectTask>();
        for ( org.apache.continuum.taskqueue.BuildProjectTask buildProjectTask : buildProjectTasks )
        {

            responses.add( (BuildProjectTask) mapper.map( buildProjectTask, BuildProjectTask.class ) );
        }
        return responses;
    }

    private ProjectSummary populateProjectSummary( org.apache.maven.continuum.model.project.Project project )
    {
        return (ProjectSummary) mapper.map( project, ProjectSummary.class );
    }

    private Project populateProject( org.apache.maven.continuum.model.project.Project project )
    {
        return (Project) mapper.map( project, Project.class );
    }

    private ProjectScmRoot populateProjectScmRoot( org.apache.continuum.model.project.ProjectScmRoot projectScmRoot )
    {
        return (ProjectScmRoot) mapper.map( projectScmRoot, ProjectScmRoot.class );
    }

    private org.apache.maven.continuum.model.project.Project populateProject( ProjectSummary projectSummary,
                                                                              org.apache.maven.continuum.model.project.Project project )
        throws ContinuumException
    {
        if ( projectSummary == null )
        {
            return null;
        }

        // validate
        if ( StringUtils.isNotBlank( projectSummary.getArtifactId() ) && !projectSummary.getArtifactId().matches(
            PROJECT_ARTIFACT_ID_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Artifact Id contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getExecutorId() ) && !projectSummary.getExecutorId().matches(
            PROJECT_EXECUTOR_OR_BUILDDEF_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Executor Id can only be 'maven2, maven-1, ant or shell'" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getGroupId() ) && !projectSummary.getGroupId().matches(
            PROJECTGROUP_ID_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Group Id contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getName() ) && !projectSummary.getName().matches(
            NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Name contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getScmTag() ) && !projectSummary.getScmTag().matches(
            PROJECT_SCM_TAG_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Scm Tag contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getScmUrl() ) && !projectSummary.getScmUrl().matches(
            PROJECT_SCM_URL_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Scm Url contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getUrl() ) && !projectSummary.getUrl().matches(
            URL_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Url contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getVersion() ) && !projectSummary.getVersion().matches(
            PROJECT_VERSION_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Version contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( projectSummary.getWorkingDirectory() ) &&
            !projectSummary.getWorkingDirectory().matches( DIRECTORY_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Project Working Directory contains invalid characters" );
        }

        project.setArtifactId( projectSummary.getArtifactId() );
        project.setBuildNumber( projectSummary.getBuildNumber() );
        project.setDescription( StringEscapeUtils.escapeXml( projectSummary.getDescription() ) );
        project.setExecutorId( projectSummary.getExecutorId() );
        project.setGroupId( projectSummary.getGroupId() );
        project.setId( projectSummary.getId() );
        project.setLatestBuildId( projectSummary.getLatestBuildId() );
        project.setName( projectSummary.getName() );
        if ( projectSummary.getProjectGroup() != null )
        {
            org.apache.maven.continuum.model.project.ProjectGroup g = continuum.getProjectGroup(
                projectSummary.getProjectGroup().getId() );
            project.setProjectGroup( populateProjectGroupSummary( projectSummary.getProjectGroup(), g ) );
        }
        else
        {
            project.setProjectGroup( null );
        }
        project.setScmTag( projectSummary.getScmTag() );
        project.setScmUrl( projectSummary.getScmUrl() );
        project.setScmUseCache( projectSummary.isScmUseCache() );
        project.setScmUsername( projectSummary.getScmUsername() );
        project.setState( projectSummary.getState() );
        project.setUrl( projectSummary.getUrl() );
        project.setVersion( projectSummary.getVersion() );
        project.setWorkingDirectory( projectSummary.getWorkingDirectory() );
        return project;
    }

    private ProjectNotifier populateProjectNotifier( org.apache.maven.continuum.model.project.ProjectNotifier notifier )
    {
        return (ProjectNotifier) mapper.map( notifier, ProjectNotifier.class );
    }

    private ProjectGroupSummary populateProjectGroupSummary(
        org.apache.maven.continuum.model.project.ProjectGroup group )
    {
        return (ProjectGroupSummary) mapper.map( group, ProjectGroupSummary.class );
    }

    private org.apache.maven.continuum.model.project.ProjectGroup populateProjectGroupSummary(
        ProjectGroupSummary group, org.apache.maven.continuum.model.project.ProjectGroup g )
        throws ContinuumException
    {
        if ( group == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( group.getGroupId() ) && !group.getGroupId().matches(
            PROJECTGROUP_ID_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "ProjectGroup Id contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( group.getName() ) && !group.getName().matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "ProjectGroup Name contains invalid characters" );
        }

        g.setDescription( StringEscapeUtils.escapeXml( group.getDescription() ) );
        g.setGroupId( group.getGroupId() );
        g.setId( group.getId() );
        g.setName( group.getName() );
        org.apache.continuum.model.repository.LocalRepository repo =
            new org.apache.continuum.model.repository.LocalRepository();
        g.setLocalRepository( populateLocalRepository( group.getLocalRepository(), repo ) );
        return g;
    }

    private ProjectGroup populateProjectGroupWithAllDetails(
        org.apache.maven.continuum.model.project.ProjectGroup group )
    {
        return (ProjectGroup) mapper.map( group, ProjectGroup.class );
    }

    private BuildResultSummary populateBuildResultSummary(
        org.apache.maven.continuum.model.project.BuildResult buildResult )
    {
        return (BuildResultSummary) mapper.map( buildResult, BuildResultSummary.class );
    }

    private BuildResult populateBuildResult( org.apache.maven.continuum.model.project.BuildResult buildResult )
        throws ContinuumException
    {
        return (BuildResult) mapper.map( buildResult, BuildResult.class );
    }

    private AddingResult populateAddingResult( ContinuumProjectBuildingResult result )
    {
        if ( result == null )
        {
            return null;
        }
        AddingResult res = new AddingResult();

        if ( result.hasErrors() )
        {
            if ( StringUtils.isNotBlank( result.getErrorsAsString() ) )
            {
                res.addError( result.getErrorsAsString() );
            }
            else
            {
                for ( String error : result.getErrors() )
                {
                    res.addError( AddingResultUtil.getErrorMessage( error ) );
                }
            }
        }

        if ( result.getProjects() != null )
        {
            for ( org.apache.maven.continuum.model.project.Project project : result.getProjects() )
            {
                res.addProject( populateProjectSummary( project ) );
            }
        }

        if ( result.getProjectGroups() != null )
        {
            for ( org.apache.maven.continuum.model.project.ProjectGroup projectGroup : result.getProjectGroups() )
            {
                res.addProjectGroup( populateProjectGroupSummary( projectGroup ) );
            }
        }

        return res;
    }

    private BuildDefinition populateBuildDefinition( org.apache.maven.continuum.model.project.BuildDefinition buildDef )
    {
        return (BuildDefinition) mapper.map( buildDef, BuildDefinition.class );
    }

    protected org.apache.maven.continuum.model.project.BuildDefinition populateBuildDefinition(
        BuildDefinition buildDef, org.apache.maven.continuum.model.project.BuildDefinition bd )
        throws ContinuumException
    {
        if ( buildDef == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( buildDef.getArguments() ) && !buildDef.getArguments().matches(
            BUILD_DEFINITION_ARGUMENTS_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Build Definition Arguments contain invalid characters" );
        }

        if ( StringUtils.isNotBlank( buildDef.getBuildFile() ) && !buildDef.getBuildFile().matches(
            BUILD_DEFINITION_BUILD_FILE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Build Definition Build File contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( buildDef.getGoals() ) && !buildDef.getGoals().matches(
            BUILD_DEFINITION_GOALS_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Build Definition Goals contain invalid characters" );
        }

        if ( StringUtils.isNotBlank( buildDef.getType() ) && !buildDef.getType().matches(
            PROJECT_EXECUTOR_OR_BUILDDEF_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Build Definition Type can only be 'maven2, maven-1, ant, or shell'" );
        }

        bd.setArguments( buildDef.getArguments() );
        bd.setBuildFile( buildDef.getBuildFile() );
        bd.setType( buildDef.getType() );
        bd.setBuildFresh( buildDef.isBuildFresh() );
        bd.setAlwaysBuild( buildDef.isAlwaysBuild() );
        bd.setDefaultForProject( buildDef.isDefaultForProject() );
        bd.setGoals( buildDef.getGoals() );
        bd.setId( buildDef.getId() );
        if ( buildDef.getProfile() != null )
        {
            bd.setProfile( populateProfile( buildDef.getProfile(), continuum.getProfileService().getProfile(
                buildDef.getProfile().getId() ) ) );
        }
        else
        {
            bd.setProfile( null );
        }
        if ( buildDef.getSchedule() != null )
        {
            bd.setSchedule( populateSchedule( buildDef.getSchedule(), continuum.getSchedule(
                buildDef.getSchedule().getId() ) ) );
        }
        else
        {
            bd.setSchedule( null );
        }

        if ( StringUtils.isNotEmpty( buildDef.getDescription() ) )
        {
            bd.setDescription( StringEscapeUtils.escapeXml( buildDef.getDescription() ) );
        }

        return bd;
    }

    protected void buildProjectWithBuildDefinition( int projectId, int buildDefinitionId,
                                                    org.apache.continuum.utils.build.BuildTrigger buildTrigger )
        throws ContinuumException, NoBuildAgentException, NoBuildAgentInGroupException
    {
        continuum.buildProjectWithBuildDefinition( projectId, buildDefinitionId, buildTrigger );
    }

    private BuildDefinitionTemplate populateBuildDefinitionTemplate(
        org.apache.maven.continuum.model.project.BuildDefinitionTemplate bdt )
    {
        return (BuildDefinitionTemplate) mapper.map( bdt, BuildDefinitionTemplate.class );
    }

    private org.apache.maven.continuum.model.project.Schedule populateSchedule( Schedule schedule,
                                                                                org.apache.maven.continuum.model.project.Schedule s )
        throws ContinuumException
    {
        if ( schedule == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( schedule.getCronExpression() ) && !schedule.getCronExpression().matches(
            SCHEDULE_CRON_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Schedule Cron Expression contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( schedule.getName() ) && !schedule.getName().matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Schedule Name contains invalid characters" );
        }

        s.setActive( schedule.isActive() );
        s.setCronExpression( schedule.getCronExpression() );
        s.setDelay( schedule.getDelay() );
        s.setDescription( StringEscapeUtils.escapeXml( schedule.getDescription() ) );
        s.setId( schedule.getId() );
        s.setMaxJobExecutionTime( schedule.getMaxJobExecutionTime() );
        s.setName( schedule.getName() );
        return s;
    }

    private Schedule populateSchedule( org.apache.maven.continuum.model.project.Schedule schedule )
    {
        return (Schedule) mapper.map( schedule, Schedule.class );
    }

    private org.apache.maven.continuum.model.system.Profile populateProfile( Profile profile,
                                                                             org.apache.maven.continuum.model.system.Profile newProfile )
        throws ContinuumException
    {
        if ( profile == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( profile.getName() ) && !profile.getName().matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Build Environment Name contains invalid characters" );
        }

        try
        {
            newProfile.setActive( profile.isActive() );
            newProfile.setBuildWithoutChanges( profile.isBuildWithoutChanges() );
            newProfile.setDescription( StringEscapeUtils.escapeXml( profile.getDescription() ) );
            newProfile.setName( profile.getName() );
            newProfile.setScmMode( profile.getScmMode() );
            newProfile.setBuildAgentGroup( profile.getBuildAgentGroup() );
            if ( profile.getBuilder() != null )
            {
                final org.apache.maven.continuum.model.system.Installation newBuilder =
                    continuum.getInstallationService().getInstallation( profile.getBuilder().getInstallationId() );
                newProfile.setBuilder( populateInstallation( profile.getBuilder(), newBuilder ) );

            }
            else
            {
                newProfile.setBuilder( null );
            }
            if ( profile.getJdk() != null )
            {
                final org.apache.maven.continuum.model.system.Installation newJdk =
                    continuum.getInstallationService().getInstallation( profile.getJdk().getInstallationId() );
                newProfile.setJdk( populateInstallation( profile.getJdk(), newJdk ) );

            }
            else
            {
                newProfile.setJdk( null );
            }
            newProfile.getEnvironmentVariables().clear();
            if ( profile.getEnvironmentVariables() != null )
            {
                for ( final Installation varEnv : profile.getEnvironmentVariables() )
                {
                    final org.apache.maven.continuum.model.system.Installation newInst =
                        continuum.getInstallationService().getInstallation( varEnv.getInstallationId() );
                    newProfile.getEnvironmentVariables().add( populateInstallation( varEnv, newInst ) );

                }
            }
            return newProfile;
        }
        catch ( InstallationException e )
        {
            throw new ContinuumException( "Can't load installations", e );
        }
    }

    private Profile populateProfile( org.apache.maven.continuum.model.system.Profile profile )
    {
        return (Profile) mapper.map( profile, Profile.class );
    }

    private org.apache.maven.continuum.model.system.Installation populateInstallation( Installation install,
                                                                                       org.apache.maven.continuum.model.system.Installation inst )
        throws ContinuumException
    {
        if ( install == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( install.getName() ) && !install.getName().matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Installation Name contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( install.getType() ) && !install.getType().matches(
            INSTALLATION_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Installation Type contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( install.getVarName() ) && !install.getVarName().matches(
            INSTALLATION_VARNAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Installation VarName contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( install.getVarValue() ) && !install.getVarValue().matches(
            INSTALLATION_VARVALUE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Installation VarValue contains invalid characters" );
        }

        inst.setName( install.getName() );
        inst.setType( install.getType() );
        inst.setVarName( install.getVarName() );
        inst.setVarValue( install.getVarValue() );
        return inst;
    }

    private Installation populateInstallation( org.apache.maven.continuum.model.system.Installation install )
    {
        return (Installation) mapper.map( install, Installation.class );
    }

    private SystemConfiguration populateSystemConfiguration(
        org.apache.maven.continuum.model.system.SystemConfiguration sysConf )
    {
        return (SystemConfiguration) mapper.map( sysConf, SystemConfiguration.class );
    }

    private ContinuumReleaseResult populateReleaseResult(
        org.apache.continuum.model.release.ContinuumReleaseResult releaseResult )
    {
        return (ContinuumReleaseResult) mapper.map( releaseResult, ContinuumReleaseResult.class );
    }

    private RepositoryPurgeConfiguration populateRepositoryPurgeConfiguration(
        org.apache.continuum.model.repository.RepositoryPurgeConfiguration repoPurgeConfig )
    {
        return (RepositoryPurgeConfiguration) mapper.map( repoPurgeConfig, RepositoryPurgeConfiguration.class );
    }

    private org.apache.continuum.model.repository.RepositoryPurgeConfiguration populateRepositoryPurgeConfiguration(
        RepositoryPurgeConfiguration repoPurgeConfig,
        org.apache.continuum.model.repository.RepositoryPurgeConfiguration repoPurge )
        throws RepositoryServiceException, ContinuumException
    {
        if ( repoPurgeConfig == null )
        {
            return null;
        }

        repoPurge.setDaysOlder( repoPurgeConfig.getDaysOlder() );
        repoPurge.setDefaultPurge( repoPurgeConfig.isDefaultPurge() );
        repoPurge.setDeleteAll( repoPurgeConfig.isDeleteAll() );
        repoPurge.setDeleteReleasedSnapshots( repoPurgeConfig.isDeleteReleasedSnapshots() );
        repoPurge.setDescription( StringEscapeUtils.escapeXml( repoPurgeConfig.getDescription() ) );
        repoPurge.setEnabled( repoPurgeConfig.isEnabled() );
        repoPurge.setRetentionCount( repoPurgeConfig.getRetentionCount() );
        if ( repoPurgeConfig.getRepository() != null )
        {
            repoPurge.setRepository( populateLocalRepository( repoPurgeConfig.getRepository(),
                                                              continuum.getRepositoryService().getLocalRepository(
                                                                  repoPurgeConfig.getRepository().getId() )
            ) );
        }
        else
        {
            repoPurge.setRepository( null );
        }
        if ( repoPurgeConfig.getSchedule() != null )
        {
            repoPurge.setSchedule( populateSchedule( repoPurgeConfig.getSchedule(), continuum.getSchedule(
                repoPurgeConfig.getSchedule().getId() ) ) );
        }
        else
        {
            repoPurge.setSchedule( null );
        }

        return repoPurge;
    }

    private DirectoryPurgeConfiguration populateDirectoryPurgeConfiguration(
        org.apache.continuum.model.repository.DirectoryPurgeConfiguration dirPurgeConfig )
    {
        return (DirectoryPurgeConfiguration) mapper.map( dirPurgeConfig, DirectoryPurgeConfiguration.class );
    }

    private org.apache.continuum.model.repository.DirectoryPurgeConfiguration populateDirectoryPurgeConfiguration(
        DirectoryPurgeConfiguration dirPurgeConfig,
        org.apache.continuum.model.repository.DirectoryPurgeConfiguration dirPurge )
        throws RepositoryServiceException, ContinuumException
    {
        if ( dirPurgeConfig == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( dirPurgeConfig.getDirectoryType() ) && !dirPurgeConfig.getDirectoryType().matches(
            DIRECTORY_TYPE_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Directory Purge Configuration Type can only be 'releases or buildOutput'" );
        }

        if ( StringUtils.isNotBlank( dirPurgeConfig.getLocation() ) && !dirPurgeConfig.getLocation().matches(
            DIRECTORY_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Directory Purge Configuration Location contains invalid characters" );
        }

        dirPurge.setDaysOlder( dirPurgeConfig.getDaysOlder() );
        dirPurge.setDefaultPurge( dirPurgeConfig.isDefaultPurge() );
        dirPurge.setDeleteAll( dirPurgeConfig.isDeleteAll() );
        dirPurge.setDescription( StringEscapeUtils.escapeXml( dirPurgeConfig.getDescription() ) );
        dirPurge.setDirectoryType( dirPurgeConfig.getDirectoryType() );
        dirPurge.setEnabled( dirPurgeConfig.isEnabled() );

        String path = "";

        if ( dirPurge.getDirectoryType().equals( "releases" ) )
        {
            path = continuum.getConfiguration().getWorkingDirectory().getAbsolutePath();
        }
        else if ( dirPurge.getDirectoryType().equals( "buildOutput" ) )
        {
            path = continuum.getConfiguration().getBuildOutputDirectory().getAbsolutePath();
        }

        dirPurge.setLocation( path );
        dirPurge.setRetentionCount( dirPurgeConfig.getRetentionCount() );
        if ( dirPurgeConfig.getSchedule() != null )
        {
            dirPurge.setSchedule( populateSchedule( dirPurgeConfig.getSchedule(), continuum.getSchedule(
                dirPurgeConfig.getSchedule().getId() ) ) );
        }
        else
        {
            dirPurge.setSchedule( null );
        }

        return dirPurge;
    }

    private LocalRepository populateLocalRepository(
        org.apache.continuum.model.repository.LocalRepository localRepository )
    {
        return (LocalRepository) mapper.map( localRepository, LocalRepository.class );
    }

    private org.apache.continuum.model.repository.LocalRepository populateLocalRepository( LocalRepository repository,
                                                                                           org.apache.continuum.model.repository.LocalRepository repo )
        throws ContinuumException
    {
        if ( repository == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( repository.getLayout() ) && !repository.getLayout().matches(
            REPOSITORY_LAYOUT_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Repository Layout can only be 'default or legacy'" );
        }

        if ( StringUtils.isNotBlank( repository.getLocation() ) && !repository.getLocation().matches(
            DIRECTORY_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Repository Location contains invalid characters" );
        }

        if ( StringUtils.isNotBlank( repository.getName() ) && !repository.getName().matches( NAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Repository Name contains invalid characters" );
        }

        repo.setLayout( repository.getLayout() );
        repo.setLocation( repository.getLocation() );
        repo.setName( repository.getName() );
        return repo;
    }

    private org.apache.continuum.utils.build.BuildTrigger populateBuildTrigger( BuildTrigger buildTrigger )
        throws ContinuumException
    {
        if ( buildTrigger == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( buildTrigger.getTriggeredBy() ) && !buildTrigger.getTriggeredBy().matches(
            USERNAME_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "BuildTrigger Triggered By contains invalid characters" );
        }

        return new org.apache.continuum.utils.build.BuildTrigger( buildTrigger.getTrigger(),
                                                                  buildTrigger.getTriggeredBy() );
    }

    private org.apache.continuum.configuration.BuildAgentConfiguration populateBuildAgent(
        BuildAgentConfiguration buildAgent )
        throws ContinuumException
    {
        if ( buildAgent == null )
        {
            return null;
        }

        if ( StringUtils.isNotBlank( buildAgent.getUrl() ) && !buildAgent.getUrl().matches( URL_VALID_EXPRESSION ) )
        {
            throw new ContinuumException( "Build Agent URL contains invalid characters" );
        }

        org.apache.continuum.configuration.BuildAgentConfiguration buildAgentConfiguration =
            new org.apache.continuum.configuration.BuildAgentConfiguration();
        buildAgentConfiguration.setUrl( buildAgent.getUrl() );
        buildAgentConfiguration.setDescription( StringEscapeUtils.escapeXml( buildAgent.getDescription() ) );
        buildAgentConfiguration.setEnabled( buildAgent.isEnabled() );
        return buildAgentConfiguration;
    }

    private BuildAgentConfiguration populateBuildAgent(
        org.apache.continuum.configuration.BuildAgentConfiguration buildAgent )
    {
        BuildAgentConfiguration buildAgentConfiguration = (BuildAgentConfiguration) mapper.map( buildAgent,
                                                                                                BuildAgentConfiguration.class );
        try
        {
            buildAgentConfiguration.setPlatform( distributedBuildManager.getBuildAgentPlatform(
                buildAgentConfiguration.getUrl() ) );
            return buildAgentConfiguration;
        }
        catch ( ContinuumException e )
        {
            logger.warn( "Unable to connect to build agent " + buildAgentConfiguration.getUrl() + ".", e );
            buildAgentConfiguration.setPlatform( "" );
            return buildAgentConfiguration;
        }
    }

    private org.apache.continuum.configuration.BuildAgentGroupConfiguration populateBuildAgentGroup(
        BuildAgentGroupConfiguration buildAgentGroup )
        throws ContinuumException
    {
        if ( buildAgentGroup == null )
        {
            return null;
        }

        org.apache.continuum.configuration.BuildAgentGroupConfiguration buildAgentGroupConfiguration =
            new org.apache.continuum.configuration.BuildAgentGroupConfiguration();

        if ( StringUtils.isBlank( buildAgentGroup.getName() ) )
        {
            throw new ContinuumException( "Build agent group name is required" );
        }

        buildAgentGroupConfiguration.setName( StringEscapeUtils.escapeXml( buildAgentGroup.getName() ) );

        buildAgentGroupConfiguration.getBuildAgents().clear();
        if ( buildAgentGroup.getBuildAgents() != null )
        {
            for ( BuildAgentConfiguration buildAgent : buildAgentGroup.getBuildAgents() )
            {
                buildAgentGroupConfiguration.getBuildAgents().add( populateBuildAgent( buildAgent ) );
            }
        }
        return buildAgentGroupConfiguration;
    }

    private BuildAgentGroupConfiguration populateBuildAgentGroup(
        org.apache.continuum.configuration.BuildAgentGroupConfiguration buildAgentGroup )
    {
        return (BuildAgentGroupConfiguration) mapper.map( buildAgentGroup, BuildAgentGroupConfiguration.class );
    }

    private Map<String, Object> serializeObject( Object o, final String... ignore )
    {
        if ( o != null )
        {
            return serializeObject( o, o.getClass(), ignore );
        }
        else
        {
            return null;
        }
    }

    private Map<String, Object> serializeObject( Object o, Class clasz, final String... ignore )
    {

        final List<String> ignoreList = ignore == null ? new ArrayList<String>() : Arrays.asList( ignore );
        if ( o != null )
        {
            final Map<String, Object> retValue = new HashMap<String, Object>();
            if ( !Object.class.equals( clasz.getSuperclass() ) )
            {
                retValue.putAll( serializeObject( o, clasz.getSuperclass(), ignore ) );
            }

            final Field[] fields = clasz.getDeclaredFields();

            retValue.put( "__class", clasz.getName() );
            for ( final Field field : fields )
            {

                if ( !ignoreList.contains( field.getName() ) )
                {
                    field.setAccessible( true );
                    try
                    {
                        final Object tmpFO = field.get( o );
                        final Object tmpNO = mapObject( tmpFO );

                        retValue.put( field.getName(), tmpNO );
                    }
                    catch ( IllegalAccessException e )
                    {
                        e.printStackTrace();
                    }
                }
            }
            return retValue;
        }
        else
        {
            return null;
        }
    }

    private Object mapObject( Object tmpFO )
    {
        final Object retValue;
        if ( tmpFO instanceof String )
        {
            Object tmpNO = serializeObject( (String) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Float )
        {
            Object tmpNO = serializeObject( (Float) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Boolean )
        {
            Object tmpNO = serializeObject( (Boolean) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Integer )
        {
            Object tmpNO = serializeObject( (Integer) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Long )
        {
            Object tmpNO = serializeObject( (Long) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Character )
        {
            Object tmpNO = serializeObject( (Character) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Byte )
        {
            Object tmpNO = serializeObject( (Byte) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Double )
        {
            Object tmpNO = serializeObject( (Double) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof List )
        {
            Object tmpNO = serializeObject( (List) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else if ( tmpFO instanceof Map )
        {
            Object tmpNO = serializeObject( (Map) tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        else
        {
            Object tmpNO = serializeObject( tmpFO );
            if ( tmpNO == null )
            {
                tmpNO = "";
            }
            retValue = tmpNO;
        }
        return retValue;
    }

    private Map<String, Object> serializeObject( Map<Object, Object> map )
    {
        final Map<String, Object> retValue = new HashMap<String, Object>();

        for ( Object key : map.keySet() )
        {
            final Object tmpKey = mapObject( key );

            if ( tmpKey != null )
            {
                retValue.put( tmpKey.toString(), mapObject( map.get( key ) ) );
            }
        }
        return retValue;
    }

    private List<Object> serializeObject( List list )
    {
        final List<Object> retValue = new ArrayList<Object>();

        for ( Object o : list )
        {
            final Object tmpO = mapObject( o );
            if ( tmpO == null )
            {
                retValue.add( "" );
            }
            else
            {
                retValue.add( tmpO );
            }
        }
        return retValue;
    }

    private String serializeObject( String o )
    {
        return o;
    }

    private String serializeObject( Byte o )
    {
        return ( o == null ? null : o.toString() );
    }

    private String serializeObject( Character o )
    {
        return ( o == null ? null : o.toString() );
    }

    private Double serializeObject( Long o )
    {
        return ( o == null ? null : o.doubleValue() );
    }

    private Double serializeObject( Float o )
    {
        return ( o == null ? null : o.doubleValue() );
    }

    private Double serializeObject( Double o )
    {
        return o;
    }

    private Integer serializeObject( Integer o )
    {
        return o;
    }

    private Boolean serializeObject( Boolean o )
    {
        return o;
    }

    private Object unserializeObject( Map<String, Object> o )
    {
        Object retValue = null;
        if ( o != null )
        {
            final String className = (String) o.remove( "__class" );

            if ( className != null )
            {
                try
                {
                    final Class clasz = Class.forName( className );
                    final Object tmpO = clasz.newInstance();
                    for ( final String key : o.keySet() )
                    {
                        final Field field = clasz.getDeclaredField( key );
                        field.setAccessible( true );
                        final Object tmpFO = o.get( key );

                        field.set( tmpO, unMapObject( tmpFO ) );
                    }
                    retValue = tmpO;
                }
                catch ( Exception e )
                {
                    e.printStackTrace();
                    retValue = null;
                }
            }
            else
            {
                // Not an object, it's a normal Map
                Map<String, Object> tmpValue = new HashMap<String, Object>();

                for ( String key : o.keySet() )
                {
                    tmpValue.put( key, unMapObject( o.get( key ) ) );
                }
                retValue = tmpValue;
            }
        }
        return retValue;
    }

    private Object unMapObject( Object tmpFO )
    {
        final Object retValue;
        if ( tmpFO instanceof String )
        {
            retValue = unserializeObject( (String) tmpFO );
        }
        else if ( tmpFO instanceof Float )
        {
            retValue = unserializeObject( (Float) tmpFO );
        }
        else if ( tmpFO instanceof Boolean )
        {
            retValue = unserializeObject( (Boolean) tmpFO );
        }
        else if ( tmpFO instanceof Integer )
        {
            retValue = unserializeObject( (Integer) tmpFO );
        }
        else if ( tmpFO instanceof Long )
        {
            retValue = unserializeObject( (Long) tmpFO );
        }
        else if ( tmpFO instanceof Character )
        {
            retValue = unserializeObject( (Character) tmpFO );
        }
        else if ( tmpFO instanceof Byte )
        {
            retValue = unserializeObject( (Byte) tmpFO );
        }
        else if ( tmpFO instanceof Double )
        {
            retValue = unserializeObject( (Double) tmpFO );
        }
        else if ( tmpFO instanceof List )
        {
            retValue = unserializeObject( (List) tmpFO );
        }
        else if ( tmpFO instanceof Map )
        {
            retValue = unserializeObject( (Map) tmpFO );
        }
        else if ( tmpFO instanceof Object[] )
        {
            retValue = unserializeObject( (Object[]) tmpFO );
        }
        else
        {
            retValue = unserializeObject( tmpFO );
        }
        return retValue;
    }

    private List<Object> unserializeObject( List list )
    {
        final List<Object> retValue = new ArrayList<Object>();

        for ( Object o : list )
        {
            retValue.add( unMapObject( o ) );
        }
        return retValue;
    }

    private Object unserializeObject( Object o )
    {
        return o;
    }

    private Object unserializeObject( Object[] list )
    {
        final List<Object> retValue = new ArrayList<Object>();

        for ( Object o : list )
        {
            retValue.add( unMapObject( o ) );
        }
        return retValue;
    }

    private String unserializeObject( String o )
    {
        return o;
    }

    private Byte unserializeObject( Byte o )
    {
        return o;
    }

    private Character unserializeObject( Character o )
    {
        return o;
    }

    private Long unserializeObject( Long o )
    {
        return o;
    }

    private Float unserializeObject( Float o )
    {
        return o;
    }

    private Double unserializeObject( Double o )
    {
        return o;
    }

    private Integer unserializeObject( Integer o )
    {
        return o;
    }

    private Boolean unserializeObject( Boolean o )
    {
        return o;
    }

    public Map<String, Object> addAntProjectRPC( Map<String, Object> project, int projectGroupId )
        throws Exception
    {
        return serializeObject( this.addAntProject( (ProjectSummary) unserializeObject( project ), projectGroupId ) );
    }

    public Map<String, Object> addBuildDefinitionToProjectGroupRPC( int projectGroupId, Map<String, Object> buildDef )
        throws Exception
    {
        return serializeObject( this.addBuildDefinitionToProjectGroup( projectGroupId,
                                                                       (BuildDefinition) unserializeObject(
                                                                           buildDef ) ) );
    }

    public Map<String, Object> addBuildDefinitionToProjectRPC( int projectId, Map<String, Object> buildDef )
        throws Exception
    {
        return serializeObject( this.addBuildDefinitionToProject( projectId, (BuildDefinition) unserializeObject(
            buildDef ) ) );
    }

    public Map<String, Object> addMavenOneProjectRPC( String url, int projectGroupId )
        throws Exception
    {
        return serializeObject( this.addMavenOneProject( url, projectGroupId ) );
    }

    public Map<String, Object> addMavenTwoProjectRPC( String url )
        throws Exception
    {
        return serializeObject( this.addMavenTwoProject( url ) );
    }

    public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId )
        throws Exception
    {
        return serializeObject( this.addMavenTwoProject( url, projectGroupId ) );
    }

    public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId,
                                                      boolean checkoutInSingleDirectory )
        throws Exception
    {
        return serializeObject( this.addMavenTwoProject( url, projectGroupId, checkoutInSingleDirectory ) );
    }

    public Map<String, Object> addMavenTwoProjectAsSingleProjectRPC( String url, int projectGroupId )
        throws Exception
    {
        return serializeObject( this.addMavenTwoProjectAsSingleProject( url, projectGroupId ) );
    }

    public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId, boolean checkProtocol,
                                                      boolean useCredentialsCache, boolean recursiveProjects,
                                                      boolean checkoutInSingleDirectory )
        throws Exception
    {
        return serializeObject( this.addMavenTwoProject( url, projectGroupId, checkProtocol, useCredentialsCache,
                                                         recursiveProjects, checkoutInSingleDirectory ) );
    }

    public Map<String, Object> addProjectGroupRPC( String groupName, String groupId, String description )
        throws Exception
    {
        return serializeObject( this.addProjectGroup( groupName, groupId, description ) );
    }

    public Map<String, Object> addScheduleRPC( Map<String, Object> schedule )
        throws Exception
    {
        return serializeObject( this.addSchedule( (Schedule) unserializeObject( schedule ) ) );
    }

    public Map<String, Object> addShellProjectRPC( Map<String, Object> project, int projectGroupId )
        throws Exception
    {
        return serializeObject( this.addShellProject( (ProjectSummary) unserializeObject( project ), projectGroupId ) );
    }

    public List<Object> getAllProjectGroupsRPC()
        throws Exception
    {
        return serializeObject( this.getAllProjectGroups() );
    }

    public List<Object> getAllProjectGroupsWithAllDetailsRPC()
        throws Exception
    {
        return serializeObject( this.getAllProjectGroupsWithAllDetails() );
    }

    public List<Object> getBuildDefinitionTemplatesRPC()
        throws Exception
    {
        return serializeObject( this.getBuildDefinitionTemplates() );
    }

    public List<Object> getBuildDefinitionsForProjectGroupRPC( int projectGroupId )
        throws Exception
    {
        return serializeObject( this.getBuildDefinitionsForProjectGroup( projectGroupId ) );
    }

    public List<Object> getBuildDefinitionsForProjectRPC( int projectId )
        throws Exception
    {
        return serializeObject( this.getBuildDefinitionsForProject( projectId ) );
    }

    public Map<String, Object> getBuildDefinitionRPC( int buildDefinitionId )
        throws Exception
    {
        return serializeObject( this.getBuildDefinition( buildDefinitionId ) );
    }

    public Map<String, Object> getBuildResultRPC( int projectId, int buildId )
        throws Exception
    {
        return serializeObject( this.getBuildResult( projectId, buildId ) );
    }

    public List<Object> getBuildResultsForProjectRPC( int projectId )
        throws Exception
    {
        return serializeObject( this.getBuildResultsForProject( projectId ) );
    }

    public Map<String, Object> getInstallationRPC( int installationId )
        throws Exception
    {
        return serializeObject( this.getInstallation( installationId ) );
    }

    public Map<String, Object> getInstallationRPC( String installationName )
        throws Exception
    {
        return serializeObject( this.getInstallation( installationName ) );
    }

    public List<Object> getInstallationsRPC()
        throws Exception
    {
        return serializeObject( this.getInstallations() );
    }

    public List<Object> getBuildAgentInstallationsRPC( String url )
        throws Exception
    {
        return serializeObject( this.getBuildAgentInstallations( url ) );
    }

    public Map<String, Object> getLatestBuildResultRPC( int projectId )
        throws Exception
    {
        return serializeObject( this.getLatestBuildResult( projectId ) );
    }

    public Map<String, Object> getProfileRPC( int profileId )
        throws Exception
    {
        return serializeObject( this.getProfile( profileId ) );
    }

    public Map<String, Object> getProfileWithNameRPC( String profileName )
        throws Exception
    {
        return serializeObject( this.getProfileWithName( profileName ) );
    }

    public List<Object> getProfilesRPC()
        throws Exception
    {
        return serializeObject( this.getProfiles() );
    }

    public Map<String, Object> getProjectGroupSummaryRPC( int projectGroupId )
        throws Exception
    {
        return serializeObject( this.getProjectGroupSummary( projectGroupId ) );
    }

    public Map<String, Object> getProjectGroupWithProjectsRPC( int projectGroupId )
        throws Exception
    {
        return serializeObject( this.getProjectGroupWithProjects( projectGroupId ) );
    }

    public Map<String, Object> updateProjectGroupRPC( Map<String, Object> projectGroup )
        throws Exception
    {
        return serializeObject( this.updateProjectGroup( (ProjectGroupSummary) unserializeObject( projectGroup ) ) );
    }

    public Map<String, Object> getProjectSummaryRPC( int projectId )
        throws Exception
    {
        return serializeObject( this.getProjectSummary( projectId ) );
    }

    public Map<String, Object> getProjectWithAllDetailsRPC( int projectId )
        throws Exception
    {
        return serializeObject( this.getProjectWithAllDetails( projectId ) );
    }

    public List<Object> getProjectsRPC( int projectGroupId )
        throws Exception
    {
        return serializeObject( this.getProjects( projectGroupId ) );
    }

    public Map<String, Object> getScheduleRPC( int scheduleId )
        throws Exception
    {
        return serializeObject( this.getSchedule( scheduleId ) );
    }

    public List<Object> getSchedulesRPC()
        throws Exception
    {
        return serializeObject( this.getSchedules() );
    }

    public Map<String, Object> getSystemConfigurationRPC()
        throws Exception
    {
        return serializeObject( this.getSystemConfiguration() );
    }

    public int removeBuildResultRPC( Map<String, Object> br )
        throws Exception
    {
        return serializeObject( this.removeBuildResult( (BuildResult) unserializeObject( br ) ) );
    }

    public Map<String, Object> updateBuildDefinitionForProjectGroupRPC( int projectGroupId,
                                                                        Map<String, Object> buildDef )
        throws Exception
    {
        return serializeObject( this.updateBuildDefinitionForProjectGroup( projectGroupId,
                                                                           (BuildDefinition) unserializeObject(
                                                                               buildDef )
        ) );
    }

    public Map<String, Object> updateBuildDefinitionForProjectRPC( int projectId, Map<String, Object> buildDef )
        throws Exception
    {
        return serializeObject( this.updateBuildDefinitionForProject( projectId, (BuildDefinition) unserializeObject(
            buildDef ) ) );
    }

    public Map<String, Object> updateProjectRPC( Map<String, Object> project )
        throws Exception
    {
        return serializeObject( this.updateProject( (ProjectSummary) unserializeObject( project ) ) );
    }

    public Map<String, Object> updateScheduleRPC( Map<String, Object> schedule )
        throws Exception
    {
        return serializeObject( this.updateSchedule( (Schedule) unserializeObject( schedule ) ) );
    }

    public Map<String, Object> getProjectGroupRPC( int projectGroupId )
        throws Exception
    {
        return serializeObject( this.getProjectGroup( projectGroupId ), "projects" );
    }

    public Map<String, Object> getGroupNotifierRPC( int projectgroupid, int notifierId )
        throws Exception
    {
        return serializeObject( this.getGroupNotifier( projectgroupid, notifierId ) );
    }

    public Map<String, Object> getNotifierRPC( int projectid, int notifierId )
        throws Exception
    {
        return serializeObject( this.getNotifier( projectid, notifierId ) );
    }

    public Map<String, Object> updateGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier )
        throws Exception
    {
        return serializeObject( this.updateGroupNotifier( projectgroupid, (ProjectNotifier) unserializeObject(
            newNotifier ) ) );
    }

    public Map<String, Object> updateNotifierRPC( int projectid, Map<String, Object> newNotifier )
        throws Exception
    {
        return serializeObject( this.updateNotifier( projectid, (ProjectNotifier) unserializeObject( newNotifier ) ) );
    }

    public Map<String, Object> addGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier )
        throws Exception
    {
        return serializeObject( this.addGroupNotifier( projectgroupid, (ProjectNotifier) unserializeObject(
            newNotifier ) ) );
    }

    public Map<String, Object> addNotifierRPC( int projectid, Map<String, Object> newNotifier )
        throws Exception
    {
        return serializeObject( this.addNotifier( projectid, (ProjectNotifier) unserializeObject( newNotifier ) ) );
    }

    public Map<String, Object> addInstallationRPC( Map<String, Object> installation )
        throws Exception
    {
        return serializeObject( this.addInstallation( (Installation) unserializeObject( installation ) ) );
    }

    public Map<String, Object> addProfileRPC( Map<String, Object> profile )
        throws Exception
    {
        return serializeObject( this.addProfile( (Profile) unserializeObject( profile ) ) );
    }

    public int updateInstallationRPC( Map<String, Object> installation )
        throws Exception
    {
        return this.updateInstallation( (Installation) unserializeObject( installation ) );
    }

    public int updateProfileRPC( Map<String, Object> profile )
        throws Exception
    {
        return this.updateProfile( (Profile) unserializeObject( profile ) );
    }

    public Map<String, Object> getReleaseResultRPC( int releaseId )
        throws Exception
    {
        return serializeObject( this.getReleaseResult( releaseId ) );
    }

    public List<Object> getReleaseResultsForProjectGroupRPC( int projectGroupId )
        throws Exception
    {
        return serializeObject( this.getReleaseResultsForProjectGroup( projectGroupId ) );
    }

    public int removeReleaseResultRPC( Map<String, Object> rr )
        throws Exception
    {
        return serializeObject( this.removeReleaseResult( (ContinuumReleaseResult) unserializeObject( rr ) ) );
    }

    public Map<String, Object> addRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge )
        throws Exception
    {
        return serializeObject( this.addRepositoryPurgeConfiguration( (RepositoryPurgeConfiguration) unserializeObject(
            repoPurge ) ) );
    }

    public int updateRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge )
        throws Exception
    {
        return serializeObject( this.updateRepositoryPurgeConfiguration(
            (RepositoryPurgeConfiguration) unserializeObject( repoPurge ) ) );
    }

    public Map<String, Object> getRepositoryPurgeConfigurationRPC( int repoPurgeId )
        throws Exception
    {
        return serializeObject( this.getRepositoryPurgeConfiguration( repoPurgeId ) );
    }

    public List<Object> getAllRepositoryPurgeConfigurationsRPC()
        throws Exception
    {
        return serializeObject( this.getAllDirectoryPurgeConfigurations() );
    }

    public Map<String, Object> addDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge )
        throws Exception
    {
        return serializeObject( this.addDirectoryPurgeConfiguration( (DirectoryPurgeConfiguration) unserializeObject(
            dirPurge ) ) );
    }

    public int updateDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge )
        throws Exception
    {
        return serializeObject( this.updateDirectoryPurgeConfiguration( (DirectoryPurgeConfiguration) unserializeObject(
            dirPurge ) ) );
    }

    public Map<String, Object> getDirectoryPurgeConfigurationRPC( int dirPurgeId )
        throws Exception
    {
        return serializeObject( this.getDirectoryPurgeConfiguration( dirPurgeId ) );
    }

    public List<Object> getAllDirectoryPurgeConfigurationsRPC()
        throws Exception
    {
        return serializeObject( this.getAllRepositoryPurgeConfigurations() );
    }

    public Map<String, Object> addLocalRepositoryRPC( Map<String, Object> repository )
        throws Exception
    {
        return serializeObject( this.addLocalRepository( (LocalRepository) unserializeObject( repository ) ) );
    }

    public int updateLocalRepositoryRPC( Map<String, Object> repository )
        throws Exception
    {
        return serializeObject( this.updateLocalRepository( (LocalRepository) unserializeObject( repository ) ) );
    }

    public Map<String, Object> getLocalRepositoryRPC( int repositoryId )
        throws Exception
    {
        return serializeObject( this.getLocalRepository( repositoryId ) );
    }

    public List<Object> getAllLocalRepositoriesRPC()
        throws Exception
    {
        return serializeObject( this.getAllLocalRepositories() );
    }

    public Map<String, Object> addBuildAgentRPC( Map<String, Object> buildAgentConfiguration )
        throws Exception
    {
        return serializeObject( this.addBuildAgent( (BuildAgentConfiguration) unserializeObject(
            buildAgentConfiguration ) ) );
    }

    public Map<String, Object> getBuildAgentRPC( String url )
    {
        return serializeObject( this.getBuildAgent( url ) );
    }

    public Map<String, Object> updateBuildAgentRPC( Map<String, Object> buildAgentConfiguration )
        throws ConfigurationStoringException, ContinuumConfigurationException
    {
        return serializeObject( this.updateBuildAgent( (BuildAgentConfiguration) unserializeObject(
            buildAgentConfiguration ) ) );
    }

    public List<Object> getAllBuildAgentsRPC()
    {
        return serializeObject( this.getAllBuildAgents() );
    }

    public List<Object> getBuildAgentsWithInstallationsRPC()
        throws Exception
    {
        return serializeObject( this.getBuildAgentsWithInstallations() );
    }

    public Map<String, Object> addBuildAgentGroupRPC( Map<String, Object> buildAgentGroup )
        throws ConfigurationException, ConfigurationStoringException, ContinuumConfigurationException
    {
        return serializeObject( this.addBuildAgentGroup( (BuildAgentGroupConfiguration) unserializeObject(
            buildAgentGroup ) ) );
    }

    public Map<String, Object> getBuildAgentGroupRPC( String name )
    {
        return serializeObject( this.getBuildAgentGroup( name ) );
    }

    public Map<String, Object> updateBuildAgentGroupRPC( Map<String, Object> buildAgentGroup )
        throws ConfigurationException, ConfigurationStoringException, ContinuumConfigurationException
    {
        return serializeObject( this.updateBuildAgentGroup( (BuildAgentGroupConfiguration) unserializeObject(
            buildAgentGroup ) ) );
    }

    public String releasePrepare( int projectId, Properties releaseProperties, Map<String, String> releaseVersions,
                                  Map<String, String> developmentVersions, Map<String, String> environments,
                                  String username )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                return continuum.getDistributedReleaseManager().releasePrepare( project, releaseProperties,
                                                                                releaseVersions, developmentVersions,
                                                                                environments, username );
            }
            else
            {
                String executable = null;

                if ( environments != null )
                {
                    String m2Home = environments.get( continuum.getInstallationService().getEnvVar(
                        InstallationService.MAVEN2_TYPE ) );
                    if ( StringUtils.isNotEmpty( m2Home ) )
                    {
                        executable = m2Home + File.separator + "bin" + File.separator + executable;
                    }
                }

                releaseProperties.setProperty( "release-by", username );
                return continuum.getReleaseManager().prepare( project, releaseProperties, releaseVersions,
                                                              developmentVersions, null, continuum.getWorkingDirectory(
                        projectId ).getPath(), environments, executable
                );
            }
        }
        else
        {
            throw new Exception(
                "Unable to prepare release project with id : " + projectId + " because it doesn't exist" );
        }
    }

    public int releasePerform( int projectId, String releaseId, String goals, String arguments,
                               boolean useReleaseProfile, String repositoryName, String username )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );

            org.apache.continuum.model.repository.LocalRepository repository =
                continuum.getRepositoryService().getLocalRepositoryByName( repositoryName );

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                continuum.getDistributedReleaseManager().releasePerform( projectId, releaseId, goals, arguments,
                                                                         useReleaseProfile, repository, username );
            }
            else
            {
                File performDirectory = new File( continuum.getConfiguration().getWorkingDirectory(),
                                                  "releases-" + System.currentTimeMillis() );
                performDirectory.mkdirs();

                continuum.getReleaseManager().perform( releaseId, performDirectory, goals, arguments, useReleaseProfile,
                                                       null, repository );
            }

            return 0;
        }
        else
        {
            throw new Exception(
                "Unable to perform release project with id : " + projectId + " because it doesn't exist" );
        }
    }

    public ReleaseListenerSummary getListener( int projectId, String releaseId )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                Map<String, Object> map = continuum.getDistributedReleaseManager().getListener( releaseId );
                return processListenerMap( map );
            }
            else
            {
                return populateReleaseListenerSummary( continuum.getReleaseManager().getListener( releaseId ) );
            }
        }
        else
        {
            throw new Exception( "Unable to get release listener for '" + releaseId + "'" );
        }
    }

    public int releaseCleanup( int projectId, String releaseId )
        throws Exception
    {
        return releaseCleanup( projectId, releaseId, null );
    }

    public int releaseCleanup( int projectId, String releaseId, String releaseType )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );
            org.apache.continuum.model.release.ContinuumReleaseResult result = continuum.addContinuumReleaseResult(
                projectId, releaseId, releaseType );

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                continuum.getDistributedReleaseManager().releaseCleanup( releaseId );
            }
            else
            {
                continuum.getReleaseManager().getReleaseResults().remove( releaseId );
                continuum.getReleaseManager().getListeners().remove( releaseId );
            }

            return result != null ? result.getId() : 0;
        }
        else
        {
            throw new Exception( "Unable to do release cleanup for release '" + releaseId + "'" );
        }
    }

    public int releaseRollback( int projectId, String releaseId )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );
            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                continuum.getDistributedReleaseManager().releaseRollback( releaseId, projectId );
            }
            else
            {
                continuum.getReleaseManager().rollback( releaseId, continuum.getWorkingDirectory( projectId ).getPath(),
                                                        null );
                continuum.getReleaseManager().getPreparedReleases().remove( releaseId );
            }
            return 0;
        }
        else
        {
            throw new Exception( "Unable to rollback the release for '" + releaseId + "'" );
        }
    }

    public Map<String, Object> getReleasePluginParameters( int projectId )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );
            Map<String, Object> params;

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                params = continuum.getDistributedReleaseManager().getReleasePluginParameters( projectId, "pom.xml" );
            }
            else
            {
                params = ReleaseUtil.getReleasePluginParameters( continuum.getWorkingDirectory( projectId ).getPath(),
                                                                 "pom.xml" );
            }

            // set scm tag and scm tag base if no values yet
            // scm tag
            if ( StringUtils.isBlank( (String) params.get( "scm-tag" ) ) )
            {
                String scmTag;
                if ( project.getScmTag() != null )
                {
                    scmTag = project.getScmTag();
                }
                else
                {
                    String version = project.getVersion();
                    int idx = version.indexOf( "-SNAPSHOT" );

                    if ( idx >= 0 )
                    {
                        // strip the snapshot version suffix
                        scmTag = project.getArtifactId() + "-" + version.substring( 0, idx );
                    }
                    else
                    {
                        scmTag = project.getArtifactId() + "-" + version;
                    }
                }

                continuum.getReleaseManager().sanitizeTagName( project.getScmUrl(), scmTag );
                params.put( "scm-tag", scmTag );
            }

            // scm tagbase
            if ( StringUtils.isBlank( (String) params.get( "scm-tagbase" ) ) )
            {
                if ( project.getScmUrl().startsWith( "scm:svn" ) )
                {
                    String scmTagBase = new SvnScmProviderRepository( project.getScmUrl(), project.getScmUsername(),
                                                                      project.getScmPassword() ).getTagBase();
                    // strip the Maven scm protocol prefix
                    params.put( "scm-tagbase", scmTagBase.substring( "scm:svn".length() + 1 ) );
                }
                else
                {
                    params.put( "scm-tagbase", "" );
                }
            }

            return params;
        }
        else
        {
            throw new Exception( "Unable to get release plugin parameters for project with id " + projectId );
        }
    }

    public List<Map<String, String>> getProjectReleaseAndDevelopmentVersions( int projectId, String pomFilename,
                                                                              boolean autoVersionSubmodules )
        throws Exception
    {
        org.apache.maven.continuum.model.project.Project project = continuum.getProject( projectId );

        if ( project != null )
        {
            checkBuildProjectInGroupAuthorization( project.getProjectGroup().getName() );
            List<Map<String, String>> projects = new ArrayList<Map<String, String>>();

            if ( continuum.getConfiguration().isDistributedBuildEnabled() )
            {
                projects = continuum.getDistributedReleaseManager().processProject( projectId, pomFilename,
                                                                                    autoVersionSubmodules );
            }
            else
            {
                ReleaseUtil.processProject( continuum.getWorkingDirectory( projectId ).getPath(), pomFilename,
                                            autoVersionSubmodules, projects );
            }

            return projects;
        }
        else
        {
            throw new Exception( "Unable to get release plugin parameters for project with id " + projectId );
        }
    }

    private ReleaseListenerSummary processListenerMap( Map<String, Object> context )
    {
        ReleaseListenerSummary listenerSummary = new ReleaseListenerSummary();
        Object value = context.get( "release-in-progress" );
        if ( value != null )
        {
            listenerSummary.setInProgress( (String) value );
        }

        value = context.get( "release-error" );
        if ( value != null )
        {
            listenerSummary.setError( (String) value );
        }

        value = context.get( "username" );
        if ( value != null )
        {
            listenerSummary.setUsername( (String) value );
        }

        value = context.get( "state" );
        if ( value != null )
        {
            listenerSummary.setState( (Integer) value );
        }

        value = context.get( "release-phases" );
        if ( value != null )
        {
            listenerSummary.setPhases( getList( value ) );
        }

        value = context.get( "completed-release-phases" );
        if ( value != null )
        {
            listenerSummary.setCompletedPhases( getList( value ) );
        }

        return listenerSummary;
    }

    private ReleaseListenerSummary populateReleaseListenerSummary(
        org.apache.continuum.model.release.ReleaseListenerSummary listener )
    {
        return (ReleaseListenerSummary) mapper.map( listener, ReleaseListenerSummary.class );
    }

    public boolean pingBuildAgent( String buildAgentUrl )
        throws Exception
    {
        return distributedBuildManager.pingBuildAgent( buildAgentUrl );
    }

    private List<String> getList( Object obj )
    {
        List<String> list = new ArrayList<String>();

        if ( obj instanceof String[] )
        {
            list.addAll( Arrays.asList( (String[]) obj ) );
        }
        else if ( obj instanceof Object[] )
        {
            // fallback needed since XMLRPC to the build agent will return a List<String> as Object[]
            for ( Object o : (Object[]) obj )
            {
                list.add( (String) o );
            }
        }
        else
        {
            list = (List<String>) obj;
        }

        return list;
    }

    // testing
    public void setContinuum( Continuum continuum )
    {
        this.continuum = continuum;
    }

    public void setDistributedBuildManager( DistributedBuildManager distributedBuildManager )
    {
        this.distributedBuildManager = distributedBuildManager;
    }

    public void setRoleManager( RoleManager roleManager )
    {
        this.roleManager = roleManager;
    }
}