Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.guvnor.structure.backend.repositories;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
 
 import  org.guvnor.structure.organizationalunit.OrganizationalUnit;
 import  org.guvnor.structure.organizationalunit.OrganizationalUnitService;
 import  org.guvnor.structure.repositories.*;
 import  org.guvnor.structure.repositories.impl.PortableVersionRecord;
 import  org.guvnor.structure.repositories.impl.git.GitRepository;
 import  org.guvnor.structure.server.config.ConfigGroup;
 import  org.guvnor.structure.server.config.ConfigItem;
 import  org.guvnor.structure.server.config.ConfigType;
 import  org.guvnor.structure.server.config.ConfigurationFactory;
 import  org.guvnor.structure.server.config.ConfigurationService;
 import  org.guvnor.structure.server.repositories.RepositoryFactory;
 import  org.uberfire.backend.server.util.TextUtil;
 import  org.uberfire.backend.vfs.Path;
 import  org.uberfire.io.IOService;
 import  org.uberfire.java.nio.base.version.VersionAttributeView;
 import  org.uberfire.java.nio.base.version.VersionRecord;
 import  org.uberfire.java.nio.file.FileSystem;
 
 import static org.guvnor.structure.backend.repositories.EnvironmentParameters.*;
 import static org.guvnor.structure.server.config.ConfigType.*;
 import static org.uberfire.backend.server.util.Paths.*;
 
 public class RepositoryServiceImpl implements RepositoryService {
 
     private static final int HISTORY_PAGE_SIZE = 10;
 
     @Inject
     @Named("ioStrategy")
     private IOService ioService;
 
     @Inject
     @Named("system")
     private Repository systemRepository;
 
     @Inject
     private ConfigurationService configurationService;
 
     @Inject
     private OrganizationalUnitService organizationalUnitService;
 
     @Inject
     private ConfigurationFactory configurationFactory;
 
     @Inject
     private RepositoryFactory repositoryFactory;
 
     @Inject
     private Event<NewRepositoryEvent> event;
 
     private Map<String, Repository> configuredRepositories = new HashMap<String, Repository>();
     private Map<Path, Repository> rootToRepo = new HashMap<Path, Repository>();
 
     @SuppressWarnings("unchecked")
     @PostConstruct
     public void loadRepositories() {
         final List<ConfigGroup> repoConfigs = .getConfiguration( REPOSITORY );
         if ( !( repoConfigs == null || repoConfigs.isEmpty() ) ) {
             for ( final ConfigGroup config : repoConfigs ) {
                 final Repository repository = .newRepository( config );
                 .put( repository.getAlias(), repository );
                 .put( repository.getRoot(), repository );
             }
         }
 
         .onNewFileSystem( new IOService.NewFileSystemListener() {
 
             @Override
             public void executefinal FileSystem newFileSystem,
                                  final String scheme,
                                  final String name,
                                  final Map<String, ?> env ) {
                 if ( getRepositoryname ) == null ) {
                     createRepositoryschemename, (Map<StringObject>) env );
                 }
             }
         } );
     }
 
     @Override
     public Repository getRepositoryfinal String alias ) {
        return .get( alias );
    }
    public Repository getRepositoryfinal FileSystem fs ) {
        if ( fs == null ) {
            return null;
        }
        for ( final Repository repository : .values() ) {
            if ( convert( repository.getRoot() ).getFileSystem().equals( fs ) ) {
                return repository;
            }
        }
        if ( convert( .getRoot() ).getFileSystem().equals( fs ) ) {
            return ;
        }
        return null;
    }
    @Override
    public Repository getRepositoryfinal Path root ) {
        // MIGHT NOT FIND IF IN ANOTHER BRANCH!!!!!!
        return .get( root );
    }
    @Override
    public Collection<Repository> getRepositories() {
        return new ArrayList<Repository>( .values() );
    }
    @Override
    public Repository createRepositoryfinal OrganizationalUnit organizationalUnit,
                                        final String scheme,
                                        final String alias,
                                        final Map<StringObjectenv ) throws RepositoryAlreadyExistsException {
        final Repository repository = createRepository(schemealiasenv);
        if ( organizationalUnit != null ) {
            .addRepository( organizationalUnitrepository );
        }
        return repository;
    }
    @Override
    public Repository createRepositoryfinal String scheme,
                                        final String alias,
                                        final Map<StringObjectenv ) {
        if ( .containsKey( alias ) || ..getAlias().equals( alias ) ) {
            throw new RepositoryAlreadyExistsException( alias );
        }
        final ConfigGroup repositoryConfig = .newConfigGroup( REPOSITORY, alias"" );
        repositoryConfig.addConfigItem( .newConfigItem( "security:roles"new ArrayList<String>() ) );
        if ( !env.containsKey ) ) {
            repositoryConfig.addConfigItem( .newConfigItem( scheme ) );
        }
        if ( env.containsKey ) ) {
            repositoryConfig.addConfigItem( .newConfigItem( env.get ) ) );
        }
        for ( final Map.Entry<StringObjectentry : env.entrySet() ) {
            if ( entry.getKey().startsWith"crypt:" ) ) {
                repositoryConfig.addConfigItem( .newSecuredConfigItem( entry.getKey(),
                                                                                           entry.getValue().toString() ) );
            } else {
                repositoryConfig.addConfigItem( .newConfigItem( entry.getKey(),
                                                                                    entry.getValue() ) );
            }
        }
        final Repository repo = createRepositoryrepositoryConfig );
        .fire( new NewRepositoryEvent( repo ) );
        return repo;
    }
    //Save the definition
    private Repository createRepositoryfinal ConfigGroup repositoryConfig ) {
        final Repository repository = .newRepository(repositoryConfig);
        .addConfiguration( repositoryConfig );
        .put( repository.getAlias(), repository );
        .put( repository.getRoot(), repository );
        return repository;
    }
    @Override
    public String normalizeRepositoryNameString name ) {
        return TextUtil.normalizeRepositoryName( name );
    }
    @SuppressWarnings({ "unchecked""rawtypes" })
    @Override
    public void addRole( Repository repository,
                         String role ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfig(repository.getAlias());
        if ( thisRepositoryConfig != null ) {
            final ConfigItem<Listroles = thisRepositoryConfig.getConfigItem( "security:roles" );
            roles.getValue().add( role );
            .updateConfiguration( thisRepositoryConfig );
            final Repository updatedRepo = .newRepository( thisRepositoryConfig );
            .put( updatedRepo.getAlias(), updatedRepo );
            .put( updatedRepo.getRoot(), updatedRepo );
        } else {
            throw new IllegalArgumentException"Repository " + repository.getAlias() + " not found" );
        }
    }
    @SuppressWarnings({ "unchecked""rawtypes" })
    @Override
    public void removeRole( Repository repository,
                            String role ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfigrepository.getAlias() );
        if ( thisRepositoryConfig != null ) {
            final ConfigItem<Listroles = thisRepositoryConfig.getConfigItem( "security:roles" );
            roles.getValue().remove( role );
            .updateConfiguration( thisRepositoryConfig );
            final Repository updatedRepo = .newRepository( thisRepositoryConfig );
            .put( updatedRepo.getAlias(), updatedRepo );
            .put( updatedRepo.getRoot(), updatedRepo );
        } else {
            throw new IllegalArgumentException"Repository " + repository.getAlias() + " not found" );
        }
    }
    protected ConfigGroup findRepositoryConfigfinal String alias ) {
        final Collection<ConfigGroup> groups = .getConfiguration(ConfigType.REPOSITORY);
        if ( groups != null ) {
            for ( ConfigGroup groupConfig : groups ) {
                if ( groupConfig.getName().equals( alias ) ) {
                    return groupConfig;
                }
            }
        }
        return null;
    }
    @Override
    public void removeRepositoryString alias ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfig(alias);
        if ( thisRepositoryConfig != null ) {
            .removeConfiguration( thisRepositoryConfig );
            final Repository repo = .remove( alias );
            if ( repo != null ) {
                .remove( repo.getRoot() );
                .delete( convert( repo.getRoot() ).getFileSystem().getPath( null ) );
            }
        }
        //Remove reference to Repository from Organizational Units
        final Collection<OrganizationalUnit> organizationalUnits = .getOrganizationalUnits();
        for ( OrganizationalUnit ou : organizationalUnits ) {
            for ( Repository repository : ou.getRepositories() ) {
                if ( repository.getAlias().equals( alias ) ) {
                    .removeRepository( ou,
                                                                repository );
                }
            }
        }
    }
    @Override
    public Repository updateRepository( Repository repository,
                                        Map<StringObjectconfig ) {
        final ConfigGroup thisRepositoryConfig = findRepositoryConfigrepository.getAlias() );
        if ( thisRepositoryConfig != null && config != null ) {
            for ( Map.Entry<StringObjectentry : config.entrySet() ) {
                ConfigItem configItem = thisRepositoryConfig.getConfigItem( entry.getKey() );
                if ( configItem == null ) {
                    thisRepositoryConfig.addConfigItem( .newConfigItem( entry.getKey(), entry.getValue() ) );
                } else {
                    configItem.setValue( entry.getValue() );
                }
            }
            .updateConfiguration( thisRepositoryConfig );
            final Repository updatedRepo = .newRepository( thisRepositoryConfig );
            .put( updatedRepo.getAlias(), updatedRepo );
            .put( updatedRepo.getRoot(), updatedRepo );
            return updatedRepo;
        } else {
            throw new IllegalArgumentException"Repository " + repository.getAlias() + " not found" );
        }
    }
    public RepositoryInfo getRepositoryInfofinal String alias ) {
        final Repository repo = getRepositoryalias );
        String ouName = null;
        for ( final OrganizationalUnit ou : .getOrganizationalUnits() ) {
            for ( Repository repository : ou.getRepositories() ) {
                if ( repository.getAlias().equals( alias ) ) {
                    ouName = ou.getName();
                }
            }
        }
        List<VersionRecord> initialRecordList = getRepositoryHistoryalias, 0, );
        return new RepositoryInfo( aliasouNamerepo.getRoot(), repo.getPublicURIs(), initialRecordList);
    }
    @Override
    public List<VersionRecord> getRepositoryHistoryString aliasint startIndex ) {
        return getRepositoryHistory(aliasstartIndexstartIndex + );
    }
    @Override
    public List<VersionRecord> getRepositoryHistoryAllString alias ) {
        return getRepositoryHistory(alias, 0, -1);
    }
    @Override
    public List<VersionRecord> getRepositoryHistoryString aliasint startIndexint endIndex ) {
        final Repository repo = getRepositoryalias );
        final VersionAttributeView versionAttributeView = .getFileAttributeView( convert( repo.getRoot() ), VersionAttributeView.class );
        final List<VersionRecord> records = versionAttributeView.readAttributes().history().records();
        if ( startIndex < 0 ) {
            startIndex = 0;
        }
        if ( endIndex < 0 || endIndex > records.size()) {
            endIndex = records.size();
        }
        if ( startIndex >= records.size() || startIndex >= endIndex) {
            return Collections.emptyList();
        }
        Collections.reverserecords );
        List<VersionRecord> result = new ArrayList<VersionRecord>( endIndex - startIndex );
        for ( VersionRecord record : records.subList( startIndexendIndex ) ) {
            result.add( new PortableVersionRecord( record.id(), record.author(), record.email(), record.comment(), record.date(), record.uri() ) );
        }
        return result;
    }
        flush();
    }
    public void updateBranch(@Observes NewBranchEvent changedEvent) {
        if (.containsKey(changedEvent.getRepositoryAlias())) {
            Repository repository = .get(changedEvent.getRepositoryAlias());
            if (repository instanceof GitRepository) {
                ((GitRepository) repository).addBranch(changedEvent.getBranchName(), changedEvent.getBranchPath());
            }
        }
    }
    private void flush() {
        .clear();
        loadRepositories();
    }
New to GrepCode? Check out our FAQ X