001    
002    package org.apache.archiva.configuration.io.registry;
003    
004    import org.apache.archiva.redback.components.registry.Registry;
005    
006    // Util imports
007    import java.util.*;
008    
009    // Model class imports
010    import org.apache.archiva.configuration.Configuration;
011    import org.apache.archiva.configuration.AbstractRepositoryConfiguration;
012    import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
013    import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
014    import org.apache.archiva.configuration.V1RepositoryConfiguration;
015    import org.apache.archiva.configuration.LegacyArtifactPath;
016    import org.apache.archiva.configuration.RepositoryGroupConfiguration;
017    import org.apache.archiva.configuration.AbstractRepositoryConnectorConfiguration;
018    import org.apache.archiva.configuration.ProxyConnectorRuleConfiguration;
019    import org.apache.archiva.configuration.ProxyConnectorConfiguration;
020    import org.apache.archiva.configuration.SyncConnectorConfiguration;
021    import org.apache.archiva.configuration.NetworkProxyConfiguration;
022    import org.apache.archiva.configuration.RepositoryScanningConfiguration;
023    import org.apache.archiva.configuration.FileType;
024    import org.apache.archiva.configuration.OrganisationInformation;
025    import org.apache.archiva.configuration.WebappConfiguration;
026    import org.apache.archiva.configuration.UserInterfaceOptions;
027    import org.apache.archiva.configuration.NetworkConfiguration;
028    import org.apache.archiva.configuration.ArchivaRuntimeConfiguration;
029    import org.apache.archiva.configuration.RedbackRuntimeConfiguration;
030    import org.apache.archiva.configuration.LdapConfiguration;
031    import org.apache.archiva.configuration.CacheConfiguration;
032    import org.apache.archiva.configuration.LdapGroupMapping;
033    
034    
035    
036    
037    /**
038     * Generate Redback Registry input mechanism for model 'Configuration'.
039     */
040    public class ConfigurationRegistryReader
041    {
042        public Configuration read( Registry registry )
043        {
044            return readConfiguration( "", registry );
045        }
046    
047        private Configuration readConfiguration( String prefix, Registry registry )
048        {
049            Configuration value = new Configuration();
050    
051        //String version = registry.getString( prefix + "version", value.getVersion() );
052    
053        List<String> versionList = registry.getList( prefix + "version" );
054        String version = value.getVersion();
055        if (versionList != null && !versionList.isEmpty() )
056        {
057            StringBuilder sb = new StringBuilder(  );
058            for (int i = 0,size = versionList.size();i<size;i++)
059            {
060                sb.append( versionList.get( i ) );
061                if (i<size - 1)
062                {
063                    sb.append( ',' );
064                }
065            }
066            version = sb.toString();
067        }
068    
069            value.setVersion( version );
070            java.util.List repositories = new java.util.ArrayList/*<V1RepositoryConfiguration>*/();
071            List repositoriesSubsets = registry.getSubsetList( prefix + "repositories.repository" );
072            for ( Iterator i = repositoriesSubsets.iterator(); i.hasNext(); )
073            {
074                V1RepositoryConfiguration v = readV1RepositoryConfiguration( "", (Registry) i.next() );
075                repositories.add( v );
076            }
077            value.setRepositories( repositories );
078            java.util.List repositoryGroups = new java.util.ArrayList/*<RepositoryGroupConfiguration>*/();
079            List repositoryGroupsSubsets = registry.getSubsetList( prefix + "repositoryGroups.repositoryGroup" );
080            for ( Iterator i = repositoryGroupsSubsets.iterator(); i.hasNext(); )
081            {
082                RepositoryGroupConfiguration v = readRepositoryGroupConfiguration( "", (Registry) i.next() );
083                repositoryGroups.add( v );
084            }
085            value.setRepositoryGroups( repositoryGroups );
086            java.util.List managedRepositories = new java.util.ArrayList/*<ManagedRepositoryConfiguration>*/();
087            List managedRepositoriesSubsets = registry.getSubsetList( prefix + "managedRepositories.managedRepository" );
088            for ( Iterator i = managedRepositoriesSubsets.iterator(); i.hasNext(); )
089            {
090                ManagedRepositoryConfiguration v = readManagedRepositoryConfiguration( "", (Registry) i.next() );
091                managedRepositories.add( v );
092            }
093            value.setManagedRepositories( managedRepositories );
094            java.util.List remoteRepositories = new java.util.ArrayList/*<RemoteRepositoryConfiguration>*/();
095            List remoteRepositoriesSubsets = registry.getSubsetList( prefix + "remoteRepositories.remoteRepository" );
096            for ( Iterator i = remoteRepositoriesSubsets.iterator(); i.hasNext(); )
097            {
098                RemoteRepositoryConfiguration v = readRemoteRepositoryConfiguration( "", (Registry) i.next() );
099                remoteRepositories.add( v );
100            }
101            value.setRemoteRepositories( remoteRepositories );
102            java.util.List proxyConnectors = new java.util.ArrayList/*<ProxyConnectorConfiguration>*/();
103            List proxyConnectorsSubsets = registry.getSubsetList( prefix + "proxyConnectors.proxyConnector" );
104            for ( Iterator i = proxyConnectorsSubsets.iterator(); i.hasNext(); )
105            {
106                ProxyConnectorConfiguration v = readProxyConnectorConfiguration( "", (Registry) i.next() );
107                proxyConnectors.add( v );
108            }
109            value.setProxyConnectors( proxyConnectors );
110            java.util.List networkProxies = new java.util.ArrayList/*<NetworkProxyConfiguration>*/();
111            List networkProxiesSubsets = registry.getSubsetList( prefix + "networkProxies.networkProxy" );
112            for ( Iterator i = networkProxiesSubsets.iterator(); i.hasNext(); )
113            {
114                NetworkProxyConfiguration v = readNetworkProxyConfiguration( "", (Registry) i.next() );
115                networkProxies.add( v );
116            }
117            value.setNetworkProxies( networkProxies );
118            java.util.List legacyArtifactPaths = new java.util.ArrayList/*<LegacyArtifactPath>*/();
119            List legacyArtifactPathsSubsets = registry.getSubsetList( prefix + "legacyArtifactPaths.legacyArtifactPath" );
120            for ( Iterator i = legacyArtifactPathsSubsets.iterator(); i.hasNext(); )
121            {
122                LegacyArtifactPath v = readLegacyArtifactPath( "", (Registry) i.next() );
123                legacyArtifactPaths.add( v );
124            }
125            value.setLegacyArtifactPaths( legacyArtifactPaths );
126            RepositoryScanningConfiguration repositoryScanning = readRepositoryScanningConfiguration( prefix + "repositoryScanning.", registry );
127            value.setRepositoryScanning( repositoryScanning );
128            WebappConfiguration webapp = readWebappConfiguration( prefix + "webapp.", registry );
129            value.setWebapp( webapp );
130            OrganisationInformation organisationInfo = readOrganisationInformation( prefix + "organisationInfo.", registry );
131            value.setOrganisationInfo( organisationInfo );
132            NetworkConfiguration networkConfiguration = readNetworkConfiguration( prefix + "networkConfiguration.", registry );
133            value.setNetworkConfiguration( networkConfiguration );
134            RedbackRuntimeConfiguration redbackRuntimeConfiguration = readRedbackRuntimeConfiguration( prefix + "redbackRuntimeConfiguration.", registry );
135            value.setRedbackRuntimeConfiguration( redbackRuntimeConfiguration );
136            ArchivaRuntimeConfiguration archivaRuntimeConfiguration = readArchivaRuntimeConfiguration( prefix + "archivaRuntimeConfiguration.", registry );
137            value.setArchivaRuntimeConfiguration( archivaRuntimeConfiguration );
138            java.util.List proxyConnectorRuleConfigurations = new java.util.ArrayList/*<ProxyConnectorRuleConfiguration>*/();
139            List proxyConnectorRuleConfigurationsSubsets = registry.getSubsetList( prefix + "proxyConnectorRuleConfigurations.proxyConnectorRuleConfiguration" );
140            for ( Iterator i = proxyConnectorRuleConfigurationsSubsets.iterator(); i.hasNext(); )
141            {
142                ProxyConnectorRuleConfiguration v = readProxyConnectorRuleConfiguration( "", (Registry) i.next() );
143                proxyConnectorRuleConfigurations.add( v );
144            }
145            value.setProxyConnectorRuleConfigurations( proxyConnectorRuleConfigurations );
146    
147            return value;
148        }
149        
150        private AbstractRepositoryConfiguration readAbstractRepositoryConfiguration( String prefix, Registry registry )
151        {
152            AbstractRepositoryConfiguration value = new AbstractRepositoryConfiguration();
153    
154        //String id = registry.getString( prefix + "id", value.getId() );
155    
156        List<String> idList = registry.getList( prefix + "id" );
157        String id = value.getId();
158        if (idList != null && !idList.isEmpty() )
159        {
160            StringBuilder sb = new StringBuilder(  );
161            for (int i = 0,size = idList.size();i<size;i++)
162            {
163                sb.append( idList.get( i ) );
164                if (i<size - 1)
165                {
166                    sb.append( ',' );
167                }
168            }
169            id = sb.toString();
170        }
171    
172            value.setId( id );
173        //String name = registry.getString( prefix + "name", value.getName() );
174    
175        List<String> nameList = registry.getList( prefix + "name" );
176        String name = value.getName();
177        if (nameList != null && !nameList.isEmpty() )
178        {
179            StringBuilder sb = new StringBuilder(  );
180            for (int i = 0,size = nameList.size();i<size;i++)
181            {
182                sb.append( nameList.get( i ) );
183                if (i<size - 1)
184                {
185                    sb.append( ',' );
186                }
187            }
188            name = sb.toString();
189        }
190    
191            value.setName( name );
192        //String layout = registry.getString( prefix + "layout", value.getLayout() );
193    
194        List<String> layoutList = registry.getList( prefix + "layout" );
195        String layout = value.getLayout();
196        if (layoutList != null && !layoutList.isEmpty() )
197        {
198            StringBuilder sb = new StringBuilder(  );
199            for (int i = 0,size = layoutList.size();i<size;i++)
200            {
201                sb.append( layoutList.get( i ) );
202                if (i<size - 1)
203                {
204                    sb.append( ',' );
205                }
206            }
207            layout = sb.toString();
208        }
209    
210            value.setLayout( layout );
211        //String indexDir = registry.getString( prefix + "indexDir", value.getIndexDir() );
212    
213        List<String> indexDirList = registry.getList( prefix + "indexDir" );
214        String indexDir = value.getIndexDir();
215        if (indexDirList != null && !indexDirList.isEmpty() )
216        {
217            StringBuilder sb = new StringBuilder(  );
218            for (int i = 0,size = indexDirList.size();i<size;i++)
219            {
220                sb.append( indexDirList.get( i ) );
221                if (i<size - 1)
222                {
223                    sb.append( ',' );
224                }
225            }
226            indexDir = sb.toString();
227        }
228    
229            value.setIndexDir( indexDir );
230        //String description = registry.getString( prefix + "description", value.getDescription() );
231    
232        List<String> descriptionList = registry.getList( prefix + "description" );
233        String description = value.getDescription();
234        if (descriptionList != null && !descriptionList.isEmpty() )
235        {
236            StringBuilder sb = new StringBuilder(  );
237            for (int i = 0,size = descriptionList.size();i<size;i++)
238            {
239                sb.append( descriptionList.get( i ) );
240                if (i<size - 1)
241                {
242                    sb.append( ',' );
243                }
244            }
245            description = sb.toString();
246        }
247    
248            value.setDescription( description );
249    
250            return value;
251        }
252        
253        private RemoteRepositoryConfiguration readRemoteRepositoryConfiguration( String prefix, Registry registry )
254        {
255            RemoteRepositoryConfiguration value = new RemoteRepositoryConfiguration();
256    
257        //String url = registry.getString( prefix + "url", value.getUrl() );
258    
259        List<String> urlList = registry.getList( prefix + "url" );
260        String url = value.getUrl();
261        if (urlList != null && !urlList.isEmpty() )
262        {
263            StringBuilder sb = new StringBuilder(  );
264            for (int i = 0,size = urlList.size();i<size;i++)
265            {
266                sb.append( urlList.get( i ) );
267                if (i<size - 1)
268                {
269                    sb.append( ',' );
270                }
271            }
272            url = sb.toString();
273        }
274    
275            value.setUrl( url );
276        //String username = registry.getString( prefix + "username", value.getUsername() );
277    
278        List<String> usernameList = registry.getList( prefix + "username" );
279        String username = value.getUsername();
280        if (usernameList != null && !usernameList.isEmpty() )
281        {
282            StringBuilder sb = new StringBuilder(  );
283            for (int i = 0,size = usernameList.size();i<size;i++)
284            {
285                sb.append( usernameList.get( i ) );
286                if (i<size - 1)
287                {
288                    sb.append( ',' );
289                }
290            }
291            username = sb.toString();
292        }
293    
294            value.setUsername( username );
295        //String password = registry.getString( prefix + "password", value.getPassword() );
296    
297        List<String> passwordList = registry.getList( prefix + "password" );
298        String password = value.getPassword();
299        if (passwordList != null && !passwordList.isEmpty() )
300        {
301            StringBuilder sb = new StringBuilder(  );
302            for (int i = 0,size = passwordList.size();i<size;i++)
303            {
304                sb.append( passwordList.get( i ) );
305                if (i<size - 1)
306                {
307                    sb.append( ',' );
308                }
309            }
310            password = sb.toString();
311        }
312    
313            value.setPassword( password );
314        int timeout = registry.getInt( prefix + "timeout", value.getTimeout() );
315            value.setTimeout( timeout );
316        //String refreshCronExpression = registry.getString( prefix + "refreshCronExpression", value.getRefreshCronExpression() );
317    
318        List<String> refreshCronExpressionList = registry.getList( prefix + "refreshCronExpression" );
319        String refreshCronExpression = value.getRefreshCronExpression();
320        if (refreshCronExpressionList != null && !refreshCronExpressionList.isEmpty() )
321        {
322            StringBuilder sb = new StringBuilder(  );
323            for (int i = 0,size = refreshCronExpressionList.size();i<size;i++)
324            {
325                sb.append( refreshCronExpressionList.get( i ) );
326                if (i<size - 1)
327                {
328                    sb.append( ',' );
329                }
330            }
331            refreshCronExpression = sb.toString();
332        }
333    
334            value.setRefreshCronExpression( refreshCronExpression );
335            boolean downloadRemoteIndex = registry.getBoolean( prefix + "downloadRemoteIndex", value.isDownloadRemoteIndex() );
336            value.setDownloadRemoteIndex( downloadRemoteIndex );
337        //String remoteIndexUrl = registry.getString( prefix + "remoteIndexUrl", value.getRemoteIndexUrl() );
338    
339        List<String> remoteIndexUrlList = registry.getList( prefix + "remoteIndexUrl" );
340        String remoteIndexUrl = value.getRemoteIndexUrl();
341        if (remoteIndexUrlList != null && !remoteIndexUrlList.isEmpty() )
342        {
343            StringBuilder sb = new StringBuilder(  );
344            for (int i = 0,size = remoteIndexUrlList.size();i<size;i++)
345            {
346                sb.append( remoteIndexUrlList.get( i ) );
347                if (i<size - 1)
348                {
349                    sb.append( ',' );
350                }
351            }
352            remoteIndexUrl = sb.toString();
353        }
354    
355            value.setRemoteIndexUrl( remoteIndexUrl );
356        //String remoteDownloadNetworkProxyId = registry.getString( prefix + "remoteDownloadNetworkProxyId", value.getRemoteDownloadNetworkProxyId() );
357    
358        List<String> remoteDownloadNetworkProxyIdList = registry.getList( prefix + "remoteDownloadNetworkProxyId" );
359        String remoteDownloadNetworkProxyId = value.getRemoteDownloadNetworkProxyId();
360        if (remoteDownloadNetworkProxyIdList != null && !remoteDownloadNetworkProxyIdList.isEmpty() )
361        {
362            StringBuilder sb = new StringBuilder(  );
363            for (int i = 0,size = remoteDownloadNetworkProxyIdList.size();i<size;i++)
364            {
365                sb.append( remoteDownloadNetworkProxyIdList.get( i ) );
366                if (i<size - 1)
367                {
368                    sb.append( ',' );
369                }
370            }
371            remoteDownloadNetworkProxyId = sb.toString();
372        }
373    
374            value.setRemoteDownloadNetworkProxyId( remoteDownloadNetworkProxyId );
375        int remoteDownloadTimeout = registry.getInt( prefix + "remoteDownloadTimeout", value.getRemoteDownloadTimeout() );
376            value.setRemoteDownloadTimeout( remoteDownloadTimeout );
377            boolean downloadRemoteIndexOnStartup = registry.getBoolean( prefix + "downloadRemoteIndexOnStartup", value.isDownloadRemoteIndexOnStartup() );
378            value.setDownloadRemoteIndexOnStartup( downloadRemoteIndexOnStartup );
379            java.util.Map extraParameters = registry.getProperties( prefix + "extraParameters" );
380            value.setExtraParameters( extraParameters );
381            java.util.Map extraHeaders = registry.getProperties( prefix + "extraHeaders" );
382            value.setExtraHeaders( extraHeaders );
383        //String id = registry.getString( prefix + "id", value.getId() );
384    
385        List<String> idList = registry.getList( prefix + "id" );
386        String id = value.getId();
387        if (idList != null && !idList.isEmpty() )
388        {
389            StringBuilder sb = new StringBuilder(  );
390            for (int i = 0,size = idList.size();i<size;i++)
391            {
392                sb.append( idList.get( i ) );
393                if (i<size - 1)
394                {
395                    sb.append( ',' );
396                }
397            }
398            id = sb.toString();
399        }
400    
401            value.setId( id );
402        //String name = registry.getString( prefix + "name", value.getName() );
403    
404        List<String> nameList = registry.getList( prefix + "name" );
405        String name = value.getName();
406        if (nameList != null && !nameList.isEmpty() )
407        {
408            StringBuilder sb = new StringBuilder(  );
409            for (int i = 0,size = nameList.size();i<size;i++)
410            {
411                sb.append( nameList.get( i ) );
412                if (i<size - 1)
413                {
414                    sb.append( ',' );
415                }
416            }
417            name = sb.toString();
418        }
419    
420            value.setName( name );
421        //String layout = registry.getString( prefix + "layout", value.getLayout() );
422    
423        List<String> layoutList = registry.getList( prefix + "layout" );
424        String layout = value.getLayout();
425        if (layoutList != null && !layoutList.isEmpty() )
426        {
427            StringBuilder sb = new StringBuilder(  );
428            for (int i = 0,size = layoutList.size();i<size;i++)
429            {
430                sb.append( layoutList.get( i ) );
431                if (i<size - 1)
432                {
433                    sb.append( ',' );
434                }
435            }
436            layout = sb.toString();
437        }
438    
439            value.setLayout( layout );
440        //String indexDir = registry.getString( prefix + "indexDir", value.getIndexDir() );
441    
442        List<String> indexDirList = registry.getList( prefix + "indexDir" );
443        String indexDir = value.getIndexDir();
444        if (indexDirList != null && !indexDirList.isEmpty() )
445        {
446            StringBuilder sb = new StringBuilder(  );
447            for (int i = 0,size = indexDirList.size();i<size;i++)
448            {
449                sb.append( indexDirList.get( i ) );
450                if (i<size - 1)
451                {
452                    sb.append( ',' );
453                }
454            }
455            indexDir = sb.toString();
456        }
457    
458            value.setIndexDir( indexDir );
459        //String description = registry.getString( prefix + "description", value.getDescription() );
460    
461        List<String> descriptionList = registry.getList( prefix + "description" );
462        String description = value.getDescription();
463        if (descriptionList != null && !descriptionList.isEmpty() )
464        {
465            StringBuilder sb = new StringBuilder(  );
466            for (int i = 0,size = descriptionList.size();i<size;i++)
467            {
468                sb.append( descriptionList.get( i ) );
469                if (i<size - 1)
470                {
471                    sb.append( ',' );
472                }
473            }
474            description = sb.toString();
475        }
476    
477            value.setDescription( description );
478    
479            return value;
480        }
481        
482        private ManagedRepositoryConfiguration readManagedRepositoryConfiguration( String prefix, Registry registry )
483        {
484            ManagedRepositoryConfiguration value = new ManagedRepositoryConfiguration();
485    
486        //String location = registry.getString( prefix + "location", value.getLocation() );
487    
488        List<String> locationList = registry.getList( prefix + "location" );
489        String location = value.getLocation();
490        if (locationList != null && !locationList.isEmpty() )
491        {
492            StringBuilder sb = new StringBuilder(  );
493            for (int i = 0,size = locationList.size();i<size;i++)
494            {
495                sb.append( locationList.get( i ) );
496                if (i<size - 1)
497                {
498                    sb.append( ',' );
499                }
500            }
501            location = sb.toString();
502        }
503    
504            value.setLocation( location );
505            boolean releases = registry.getBoolean( prefix + "releases", value.isReleases() );
506            value.setReleases( releases );
507            boolean blockRedeployments = registry.getBoolean( prefix + "blockRedeployments", value.isBlockRedeployments() );
508            value.setBlockRedeployments( blockRedeployments );
509            boolean snapshots = registry.getBoolean( prefix + "snapshots", value.isSnapshots() );
510            value.setSnapshots( snapshots );
511            boolean scanned = registry.getBoolean( prefix + "scanned", value.isScanned() );
512            value.setScanned( scanned );
513        //String refreshCronExpression = registry.getString( prefix + "refreshCronExpression", value.getRefreshCronExpression() );
514    
515        List<String> refreshCronExpressionList = registry.getList( prefix + "refreshCronExpression" );
516        String refreshCronExpression = value.getRefreshCronExpression();
517        if (refreshCronExpressionList != null && !refreshCronExpressionList.isEmpty() )
518        {
519            StringBuilder sb = new StringBuilder(  );
520            for (int i = 0,size = refreshCronExpressionList.size();i<size;i++)
521            {
522                sb.append( refreshCronExpressionList.get( i ) );
523                if (i<size - 1)
524                {
525                    sb.append( ',' );
526                }
527            }
528            refreshCronExpression = sb.toString();
529        }
530    
531            value.setRefreshCronExpression( refreshCronExpression );
532        int retentionCount = registry.getInt( prefix + "retentionCount", value.getRetentionCount() );
533            value.setRetentionCount( retentionCount );
534        int daysOlder = registry.getInt( prefix + "daysOlder", value.getDaysOlder() );
535            value.setDaysOlder( daysOlder );
536            boolean deleteReleasedSnapshots = registry.getBoolean( prefix + "deleteReleasedSnapshots", value.isDeleteReleasedSnapshots() );
537            value.setDeleteReleasedSnapshots( deleteReleasedSnapshots );
538            boolean skipPackedIndexCreation = registry.getBoolean( prefix + "skipPackedIndexCreation", value.isSkipPackedIndexCreation() );
539            value.setSkipPackedIndexCreation( skipPackedIndexCreation );
540            boolean stageRepoNeeded = registry.getBoolean( prefix + "stageRepoNeeded", value.isStageRepoNeeded() );
541            value.setStageRepoNeeded( stageRepoNeeded );
542        //String id = registry.getString( prefix + "id", value.getId() );
543    
544        List<String> idList = registry.getList( prefix + "id" );
545        String id = value.getId();
546        if (idList != null && !idList.isEmpty() )
547        {
548            StringBuilder sb = new StringBuilder(  );
549            for (int i = 0,size = idList.size();i<size;i++)
550            {
551                sb.append( idList.get( i ) );
552                if (i<size - 1)
553                {
554                    sb.append( ',' );
555                }
556            }
557            id = sb.toString();
558        }
559    
560            value.setId( id );
561        //String name = registry.getString( prefix + "name", value.getName() );
562    
563        List<String> nameList = registry.getList( prefix + "name" );
564        String name = value.getName();
565        if (nameList != null && !nameList.isEmpty() )
566        {
567            StringBuilder sb = new StringBuilder(  );
568            for (int i = 0,size = nameList.size();i<size;i++)
569            {
570                sb.append( nameList.get( i ) );
571                if (i<size - 1)
572                {
573                    sb.append( ',' );
574                }
575            }
576            name = sb.toString();
577        }
578    
579            value.setName( name );
580        //String layout = registry.getString( prefix + "layout", value.getLayout() );
581    
582        List<String> layoutList = registry.getList( prefix + "layout" );
583        String layout = value.getLayout();
584        if (layoutList != null && !layoutList.isEmpty() )
585        {
586            StringBuilder sb = new StringBuilder(  );
587            for (int i = 0,size = layoutList.size();i<size;i++)
588            {
589                sb.append( layoutList.get( i ) );
590                if (i<size - 1)
591                {
592                    sb.append( ',' );
593                }
594            }
595            layout = sb.toString();
596        }
597    
598            value.setLayout( layout );
599        //String indexDir = registry.getString( prefix + "indexDir", value.getIndexDir() );
600    
601        List<String> indexDirList = registry.getList( prefix + "indexDir" );
602        String indexDir = value.getIndexDir();
603        if (indexDirList != null && !indexDirList.isEmpty() )
604        {
605            StringBuilder sb = new StringBuilder(  );
606            for (int i = 0,size = indexDirList.size();i<size;i++)
607            {
608                sb.append( indexDirList.get( i ) );
609                if (i<size - 1)
610                {
611                    sb.append( ',' );
612                }
613            }
614            indexDir = sb.toString();
615        }
616    
617            value.setIndexDir( indexDir );
618        //String description = registry.getString( prefix + "description", value.getDescription() );
619    
620        List<String> descriptionList = registry.getList( prefix + "description" );
621        String description = value.getDescription();
622        if (descriptionList != null && !descriptionList.isEmpty() )
623        {
624            StringBuilder sb = new StringBuilder(  );
625            for (int i = 0,size = descriptionList.size();i<size;i++)
626            {
627                sb.append( descriptionList.get( i ) );
628                if (i<size - 1)
629                {
630                    sb.append( ',' );
631                }
632            }
633            description = sb.toString();
634        }
635    
636            value.setDescription( description );
637    
638            return value;
639        }
640        
641        private V1RepositoryConfiguration readV1RepositoryConfiguration( String prefix, Registry registry )
642        {
643            V1RepositoryConfiguration value = new V1RepositoryConfiguration();
644    
645        //String url = registry.getString( prefix + "url", value.getUrl() );
646    
647        List<String> urlList = registry.getList( prefix + "url" );
648        String url = value.getUrl();
649        if (urlList != null && !urlList.isEmpty() )
650        {
651            StringBuilder sb = new StringBuilder(  );
652            for (int i = 0,size = urlList.size();i<size;i++)
653            {
654                sb.append( urlList.get( i ) );
655                if (i<size - 1)
656                {
657                    sb.append( ',' );
658                }
659            }
660            url = sb.toString();
661        }
662    
663            value.setUrl( url );
664            boolean indexed = registry.getBoolean( prefix + "indexed", value.isIndexed() );
665            value.setIndexed( indexed );
666        //String location = registry.getString( prefix + "location", value.getLocation() );
667    
668        List<String> locationList = registry.getList( prefix + "location" );
669        String location = value.getLocation();
670        if (locationList != null && !locationList.isEmpty() )
671        {
672            StringBuilder sb = new StringBuilder(  );
673            for (int i = 0,size = locationList.size();i<size;i++)
674            {
675                sb.append( locationList.get( i ) );
676                if (i<size - 1)
677                {
678                    sb.append( ',' );
679                }
680            }
681            location = sb.toString();
682        }
683    
684            value.setLocation( location );
685            boolean releases = registry.getBoolean( prefix + "releases", value.isReleases() );
686            value.setReleases( releases );
687            boolean blockRedeployments = registry.getBoolean( prefix + "blockRedeployments", value.isBlockRedeployments() );
688            value.setBlockRedeployments( blockRedeployments );
689            boolean snapshots = registry.getBoolean( prefix + "snapshots", value.isSnapshots() );
690            value.setSnapshots( snapshots );
691            boolean scanned = registry.getBoolean( prefix + "scanned", value.isScanned() );
692            value.setScanned( scanned );
693        //String refreshCronExpression = registry.getString( prefix + "refreshCronExpression", value.getRefreshCronExpression() );
694    
695        List<String> refreshCronExpressionList = registry.getList( prefix + "refreshCronExpression" );
696        String refreshCronExpression = value.getRefreshCronExpression();
697        if (refreshCronExpressionList != null && !refreshCronExpressionList.isEmpty() )
698        {
699            StringBuilder sb = new StringBuilder(  );
700            for (int i = 0,size = refreshCronExpressionList.size();i<size;i++)
701            {
702                sb.append( refreshCronExpressionList.get( i ) );
703                if (i<size - 1)
704                {
705                    sb.append( ',' );
706                }
707            }
708            refreshCronExpression = sb.toString();
709        }
710    
711            value.setRefreshCronExpression( refreshCronExpression );
712        int retentionCount = registry.getInt( prefix + "retentionCount", value.getRetentionCount() );
713            value.setRetentionCount( retentionCount );
714        int daysOlder = registry.getInt( prefix + "daysOlder", value.getDaysOlder() );
715            value.setDaysOlder( daysOlder );
716            boolean deleteReleasedSnapshots = registry.getBoolean( prefix + "deleteReleasedSnapshots", value.isDeleteReleasedSnapshots() );
717            value.setDeleteReleasedSnapshots( deleteReleasedSnapshots );
718            boolean skipPackedIndexCreation = registry.getBoolean( prefix + "skipPackedIndexCreation", value.isSkipPackedIndexCreation() );
719            value.setSkipPackedIndexCreation( skipPackedIndexCreation );
720            boolean stageRepoNeeded = registry.getBoolean( prefix + "stageRepoNeeded", value.isStageRepoNeeded() );
721            value.setStageRepoNeeded( stageRepoNeeded );
722        //String id = registry.getString( prefix + "id", value.getId() );
723    
724        List<String> idList = registry.getList( prefix + "id" );
725        String id = value.getId();
726        if (idList != null && !idList.isEmpty() )
727        {
728            StringBuilder sb = new StringBuilder(  );
729            for (int i = 0,size = idList.size();i<size;i++)
730            {
731                sb.append( idList.get( i ) );
732                if (i<size - 1)
733                {
734                    sb.append( ',' );
735                }
736            }
737            id = sb.toString();
738        }
739    
740            value.setId( id );
741        //String name = registry.getString( prefix + "name", value.getName() );
742    
743        List<String> nameList = registry.getList( prefix + "name" );
744        String name = value.getName();
745        if (nameList != null && !nameList.isEmpty() )
746        {
747            StringBuilder sb = new StringBuilder(  );
748            for (int i = 0,size = nameList.size();i<size;i++)
749            {
750                sb.append( nameList.get( i ) );
751                if (i<size - 1)
752                {
753                    sb.append( ',' );
754                }
755            }
756            name = sb.toString();
757        }
758    
759            value.setName( name );
760        //String layout = registry.getString( prefix + "layout", value.getLayout() );
761    
762        List<String> layoutList = registry.getList( prefix + "layout" );
763        String layout = value.getLayout();
764        if (layoutList != null && !layoutList.isEmpty() )
765        {
766            StringBuilder sb = new StringBuilder(  );
767            for (int i = 0,size = layoutList.size();i<size;i++)
768            {
769                sb.append( layoutList.get( i ) );
770                if (i<size - 1)
771                {
772                    sb.append( ',' );
773                }
774            }
775            layout = sb.toString();
776        }
777    
778            value.setLayout( layout );
779        //String indexDir = registry.getString( prefix + "indexDir", value.getIndexDir() );
780    
781        List<String> indexDirList = registry.getList( prefix + "indexDir" );
782        String indexDir = value.getIndexDir();
783        if (indexDirList != null && !indexDirList.isEmpty() )
784        {
785            StringBuilder sb = new StringBuilder(  );
786            for (int i = 0,size = indexDirList.size();i<size;i++)
787            {
788                sb.append( indexDirList.get( i ) );
789                if (i<size - 1)
790                {
791                    sb.append( ',' );
792                }
793            }
794            indexDir = sb.toString();
795        }
796    
797            value.setIndexDir( indexDir );
798        //String description = registry.getString( prefix + "description", value.getDescription() );
799    
800        List<String> descriptionList = registry.getList( prefix + "description" );
801        String description = value.getDescription();
802        if (descriptionList != null && !descriptionList.isEmpty() )
803        {
804            StringBuilder sb = new StringBuilder(  );
805            for (int i = 0,size = descriptionList.size();i<size;i++)
806            {
807                sb.append( descriptionList.get( i ) );
808                if (i<size - 1)
809                {
810                    sb.append( ',' );
811                }
812            }
813            description = sb.toString();
814        }
815    
816            value.setDescription( description );
817    
818            return value;
819        }
820        
821        private LegacyArtifactPath readLegacyArtifactPath( String prefix, Registry registry )
822        {
823            LegacyArtifactPath value = new LegacyArtifactPath();
824    
825        //String path = registry.getString( prefix + "path", value.getPath() );
826    
827        List<String> pathList = registry.getList( prefix + "path" );
828        String path = value.getPath();
829        if (pathList != null && !pathList.isEmpty() )
830        {
831            StringBuilder sb = new StringBuilder(  );
832            for (int i = 0,size = pathList.size();i<size;i++)
833            {
834                sb.append( pathList.get( i ) );
835                if (i<size - 1)
836                {
837                    sb.append( ',' );
838                }
839            }
840            path = sb.toString();
841        }
842    
843            value.setPath( path );
844        //String artifact = registry.getString( prefix + "artifact", value.getArtifact() );
845    
846        List<String> artifactList = registry.getList( prefix + "artifact" );
847        String artifact = value.getArtifact();
848        if (artifactList != null && !artifactList.isEmpty() )
849        {
850            StringBuilder sb = new StringBuilder(  );
851            for (int i = 0,size = artifactList.size();i<size;i++)
852            {
853                sb.append( artifactList.get( i ) );
854                if (i<size - 1)
855                {
856                    sb.append( ',' );
857                }
858            }
859            artifact = sb.toString();
860        }
861    
862            value.setArtifact( artifact );
863    
864            return value;
865        }
866        
867        private RepositoryGroupConfiguration readRepositoryGroupConfiguration( String prefix, Registry registry )
868        {
869            RepositoryGroupConfiguration value = new RepositoryGroupConfiguration();
870    
871        //String id = registry.getString( prefix + "id", value.getId() );
872    
873        List<String> idList = registry.getList( prefix + "id" );
874        String id = value.getId();
875        if (idList != null && !idList.isEmpty() )
876        {
877            StringBuilder sb = new StringBuilder(  );
878            for (int i = 0,size = idList.size();i<size;i++)
879            {
880                sb.append( idList.get( i ) );
881                if (i<size - 1)
882                {
883                    sb.append( ',' );
884                }
885            }
886            id = sb.toString();
887        }
888    
889            value.setId( id );
890        //String mergedIndexPath = registry.getString( prefix + "mergedIndexPath", value.getMergedIndexPath() );
891    
892        List<String> mergedIndexPathList = registry.getList( prefix + "mergedIndexPath" );
893        String mergedIndexPath = value.getMergedIndexPath();
894        if (mergedIndexPathList != null && !mergedIndexPathList.isEmpty() )
895        {
896            StringBuilder sb = new StringBuilder(  );
897            for (int i = 0,size = mergedIndexPathList.size();i<size;i++)
898            {
899                sb.append( mergedIndexPathList.get( i ) );
900                if (i<size - 1)
901                {
902                    sb.append( ',' );
903                }
904            }
905            mergedIndexPath = sb.toString();
906        }
907    
908            value.setMergedIndexPath( mergedIndexPath );
909        int mergedIndexTtl = registry.getInt( prefix + "mergedIndexTtl", value.getMergedIndexTtl() );
910            value.setMergedIndexTtl( mergedIndexTtl );
911            java.util.List repositories = new java.util.ArrayList/*<String>*/();
912            repositories.addAll( registry.getList( prefix + "repositories.repository" ) );
913            value.setRepositories( repositories );
914    
915            return value;
916        }
917        
918        private AbstractRepositoryConnectorConfiguration readAbstractRepositoryConnectorConfiguration( String prefix, Registry registry )
919        {
920            AbstractRepositoryConnectorConfiguration value = new AbstractRepositoryConnectorConfiguration();
921    
922        //String sourceRepoId = registry.getString( prefix + "sourceRepoId", value.getSourceRepoId() );
923    
924        List<String> sourceRepoIdList = registry.getList( prefix + "sourceRepoId" );
925        String sourceRepoId = value.getSourceRepoId();
926        if (sourceRepoIdList != null && !sourceRepoIdList.isEmpty() )
927        {
928            StringBuilder sb = new StringBuilder(  );
929            for (int i = 0,size = sourceRepoIdList.size();i<size;i++)
930            {
931                sb.append( sourceRepoIdList.get( i ) );
932                if (i<size - 1)
933                {
934                    sb.append( ',' );
935                }
936            }
937            sourceRepoId = sb.toString();
938        }
939    
940            value.setSourceRepoId( sourceRepoId );
941        //String targetRepoId = registry.getString( prefix + "targetRepoId", value.getTargetRepoId() );
942    
943        List<String> targetRepoIdList = registry.getList( prefix + "targetRepoId" );
944        String targetRepoId = value.getTargetRepoId();
945        if (targetRepoIdList != null && !targetRepoIdList.isEmpty() )
946        {
947            StringBuilder sb = new StringBuilder(  );
948            for (int i = 0,size = targetRepoIdList.size();i<size;i++)
949            {
950                sb.append( targetRepoIdList.get( i ) );
951                if (i<size - 1)
952                {
953                    sb.append( ',' );
954                }
955            }
956            targetRepoId = sb.toString();
957        }
958    
959            value.setTargetRepoId( targetRepoId );
960        //String proxyId = registry.getString( prefix + "proxyId", value.getProxyId() );
961    
962        List<String> proxyIdList = registry.getList( prefix + "proxyId" );
963        String proxyId = value.getProxyId();
964        if (proxyIdList != null && !proxyIdList.isEmpty() )
965        {
966            StringBuilder sb = new StringBuilder(  );
967            for (int i = 0,size = proxyIdList.size();i<size;i++)
968            {
969                sb.append( proxyIdList.get( i ) );
970                if (i<size - 1)
971                {
972                    sb.append( ',' );
973                }
974            }
975            proxyId = sb.toString();
976        }
977    
978            value.setProxyId( proxyId );
979            java.util.List blackListPatterns = new java.util.ArrayList/*<String>*/();
980            blackListPatterns.addAll( registry.getList( prefix + "blackListPatterns.blackListPattern" ) );
981            value.setBlackListPatterns( blackListPatterns );
982            java.util.List whiteListPatterns = new java.util.ArrayList/*<String>*/();
983            whiteListPatterns.addAll( registry.getList( prefix + "whiteListPatterns.whiteListPattern" ) );
984            value.setWhiteListPatterns( whiteListPatterns );
985            java.util.Map policies = registry.getProperties( prefix + "policies" );
986            value.setPolicies( policies );
987            java.util.Map properties = registry.getProperties( prefix + "properties" );
988            value.setProperties( properties );
989            boolean disabled = registry.getBoolean( prefix + "disabled", value.isDisabled() );
990            value.setDisabled( disabled );
991    
992            return value;
993        }
994        
995        private ProxyConnectorRuleConfiguration readProxyConnectorRuleConfiguration( String prefix, Registry registry )
996        {
997            ProxyConnectorRuleConfiguration value = new ProxyConnectorRuleConfiguration();
998    
999        //String ruleType = registry.getString( prefix + "ruleType", value.getRuleType() );
1000    
1001        List<String> ruleTypeList = registry.getList( prefix + "ruleType" );
1002        String ruleType = value.getRuleType();
1003        if (ruleTypeList != null && !ruleTypeList.isEmpty() )
1004        {
1005            StringBuilder sb = new StringBuilder(  );
1006            for (int i = 0,size = ruleTypeList.size();i<size;i++)
1007            {
1008                sb.append( ruleTypeList.get( i ) );
1009                if (i<size - 1)
1010                {
1011                    sb.append( ',' );
1012                }
1013            }
1014            ruleType = sb.toString();
1015        }
1016    
1017            value.setRuleType( ruleType );
1018        //String pattern = registry.getString( prefix + "pattern", value.getPattern() );
1019    
1020        List<String> patternList = registry.getList( prefix + "pattern" );
1021        String pattern = value.getPattern();
1022        if (patternList != null && !patternList.isEmpty() )
1023        {
1024            StringBuilder sb = new StringBuilder(  );
1025            for (int i = 0,size = patternList.size();i<size;i++)
1026            {
1027                sb.append( patternList.get( i ) );
1028                if (i<size - 1)
1029                {
1030                    sb.append( ',' );
1031                }
1032            }
1033            pattern = sb.toString();
1034        }
1035    
1036            value.setPattern( pattern );
1037            java.util.List proxyConnectors = new java.util.ArrayList/*<ProxyConnectorConfiguration>*/();
1038            List proxyConnectorsSubsets = registry.getSubsetList( prefix + "proxyConnectors.proxyConnector" );
1039            for ( Iterator i = proxyConnectorsSubsets.iterator(); i.hasNext(); )
1040            {
1041                ProxyConnectorConfiguration v = readProxyConnectorConfiguration( "", (Registry) i.next() );
1042                proxyConnectors.add( v );
1043            }
1044            value.setProxyConnectors( proxyConnectors );
1045    
1046            return value;
1047        }
1048        
1049        private ProxyConnectorConfiguration readProxyConnectorConfiguration( String prefix, Registry registry )
1050        {
1051            ProxyConnectorConfiguration value = new ProxyConnectorConfiguration();
1052    
1053        int order = registry.getInt( prefix + "order", value.getOrder() );
1054            value.setOrder( order );
1055        //String sourceRepoId = registry.getString( prefix + "sourceRepoId", value.getSourceRepoId() );
1056    
1057        List<String> sourceRepoIdList = registry.getList( prefix + "sourceRepoId" );
1058        String sourceRepoId = value.getSourceRepoId();
1059        if (sourceRepoIdList != null && !sourceRepoIdList.isEmpty() )
1060        {
1061            StringBuilder sb = new StringBuilder(  );
1062            for (int i = 0,size = sourceRepoIdList.size();i<size;i++)
1063            {
1064                sb.append( sourceRepoIdList.get( i ) );
1065                if (i<size - 1)
1066                {
1067                    sb.append( ',' );
1068                }
1069            }
1070            sourceRepoId = sb.toString();
1071        }
1072    
1073            value.setSourceRepoId( sourceRepoId );
1074        //String targetRepoId = registry.getString( prefix + "targetRepoId", value.getTargetRepoId() );
1075    
1076        List<String> targetRepoIdList = registry.getList( prefix + "targetRepoId" );
1077        String targetRepoId = value.getTargetRepoId();
1078        if (targetRepoIdList != null && !targetRepoIdList.isEmpty() )
1079        {
1080            StringBuilder sb = new StringBuilder(  );
1081            for (int i = 0,size = targetRepoIdList.size();i<size;i++)
1082            {
1083                sb.append( targetRepoIdList.get( i ) );
1084                if (i<size - 1)
1085                {
1086                    sb.append( ',' );
1087                }
1088            }
1089            targetRepoId = sb.toString();
1090        }
1091    
1092            value.setTargetRepoId( targetRepoId );
1093        //String proxyId = registry.getString( prefix + "proxyId", value.getProxyId() );
1094    
1095        List<String> proxyIdList = registry.getList( prefix + "proxyId" );
1096        String proxyId = value.getProxyId();
1097        if (proxyIdList != null && !proxyIdList.isEmpty() )
1098        {
1099            StringBuilder sb = new StringBuilder(  );
1100            for (int i = 0,size = proxyIdList.size();i<size;i++)
1101            {
1102                sb.append( proxyIdList.get( i ) );
1103                if (i<size - 1)
1104                {
1105                    sb.append( ',' );
1106                }
1107            }
1108            proxyId = sb.toString();
1109        }
1110    
1111            value.setProxyId( proxyId );
1112            java.util.List blackListPatterns = new java.util.ArrayList/*<String>*/();
1113            blackListPatterns.addAll( registry.getList( prefix + "blackListPatterns.blackListPattern" ) );
1114            value.setBlackListPatterns( blackListPatterns );
1115            java.util.List whiteListPatterns = new java.util.ArrayList/*<String>*/();
1116            whiteListPatterns.addAll( registry.getList( prefix + "whiteListPatterns.whiteListPattern" ) );
1117            value.setWhiteListPatterns( whiteListPatterns );
1118            java.util.Map policies = registry.getProperties( prefix + "policies" );
1119            value.setPolicies( policies );
1120            java.util.Map properties = registry.getProperties( prefix + "properties" );
1121            value.setProperties( properties );
1122            boolean disabled = registry.getBoolean( prefix + "disabled", value.isDisabled() );
1123            value.setDisabled( disabled );
1124    
1125            return value;
1126        }
1127        
1128        private SyncConnectorConfiguration readSyncConnectorConfiguration( String prefix, Registry registry )
1129        {
1130            SyncConnectorConfiguration value = new SyncConnectorConfiguration();
1131    
1132        //String cronExpression = registry.getString( prefix + "cronExpression", value.getCronExpression() );
1133    
1134        List<String> cronExpressionList = registry.getList( prefix + "cronExpression" );
1135        String cronExpression = value.getCronExpression();
1136        if (cronExpressionList != null && !cronExpressionList.isEmpty() )
1137        {
1138            StringBuilder sb = new StringBuilder(  );
1139            for (int i = 0,size = cronExpressionList.size();i<size;i++)
1140            {
1141                sb.append( cronExpressionList.get( i ) );
1142                if (i<size - 1)
1143                {
1144                    sb.append( ',' );
1145                }
1146            }
1147            cronExpression = sb.toString();
1148        }
1149    
1150            value.setCronExpression( cronExpression );
1151        //String method = registry.getString( prefix + "method", value.getMethod() );
1152    
1153        List<String> methodList = registry.getList( prefix + "method" );
1154        String method = value.getMethod();
1155        if (methodList != null && !methodList.isEmpty() )
1156        {
1157            StringBuilder sb = new StringBuilder(  );
1158            for (int i = 0,size = methodList.size();i<size;i++)
1159            {
1160                sb.append( methodList.get( i ) );
1161                if (i<size - 1)
1162                {
1163                    sb.append( ',' );
1164                }
1165            }
1166            method = sb.toString();
1167        }
1168    
1169            value.setMethod( method );
1170        //String sourceRepoId = registry.getString( prefix + "sourceRepoId", value.getSourceRepoId() );
1171    
1172        List<String> sourceRepoIdList = registry.getList( prefix + "sourceRepoId" );
1173        String sourceRepoId = value.getSourceRepoId();
1174        if (sourceRepoIdList != null && !sourceRepoIdList.isEmpty() )
1175        {
1176            StringBuilder sb = new StringBuilder(  );
1177            for (int i = 0,size = sourceRepoIdList.size();i<size;i++)
1178            {
1179                sb.append( sourceRepoIdList.get( i ) );
1180                if (i<size - 1)
1181                {
1182                    sb.append( ',' );
1183                }
1184            }
1185            sourceRepoId = sb.toString();
1186        }
1187    
1188            value.setSourceRepoId( sourceRepoId );
1189        //String targetRepoId = registry.getString( prefix + "targetRepoId", value.getTargetRepoId() );
1190    
1191        List<String> targetRepoIdList = registry.getList( prefix + "targetRepoId" );
1192        String targetRepoId = value.getTargetRepoId();
1193        if (targetRepoIdList != null && !targetRepoIdList.isEmpty() )
1194        {
1195            StringBuilder sb = new StringBuilder(  );
1196            for (int i = 0,size = targetRepoIdList.size();i<size;i++)
1197            {
1198                sb.append( targetRepoIdList.get( i ) );
1199                if (i<size - 1)
1200                {
1201                    sb.append( ',' );
1202                }
1203            }
1204            targetRepoId = sb.toString();
1205        }
1206    
1207            value.setTargetRepoId( targetRepoId );
1208        //String proxyId = registry.getString( prefix + "proxyId", value.getProxyId() );
1209    
1210        List<String> proxyIdList = registry.getList( prefix + "proxyId" );
1211        String proxyId = value.getProxyId();
1212        if (proxyIdList != null && !proxyIdList.isEmpty() )
1213        {
1214            StringBuilder sb = new StringBuilder(  );
1215            for (int i = 0,size = proxyIdList.size();i<size;i++)
1216            {
1217                sb.append( proxyIdList.get( i ) );
1218                if (i<size - 1)
1219                {
1220                    sb.append( ',' );
1221                }
1222            }
1223            proxyId = sb.toString();
1224        }
1225    
1226            value.setProxyId( proxyId );
1227            java.util.List blackListPatterns = new java.util.ArrayList/*<String>*/();
1228            blackListPatterns.addAll( registry.getList( prefix + "blackListPatterns.blackListPattern" ) );
1229            value.setBlackListPatterns( blackListPatterns );
1230            java.util.List whiteListPatterns = new java.util.ArrayList/*<String>*/();
1231            whiteListPatterns.addAll( registry.getList( prefix + "whiteListPatterns.whiteListPattern" ) );
1232            value.setWhiteListPatterns( whiteListPatterns );
1233            java.util.Map policies = registry.getProperties( prefix + "policies" );
1234            value.setPolicies( policies );
1235            java.util.Map properties = registry.getProperties( prefix + "properties" );
1236            value.setProperties( properties );
1237            boolean disabled = registry.getBoolean( prefix + "disabled", value.isDisabled() );
1238            value.setDisabled( disabled );
1239    
1240            return value;
1241        }
1242        
1243        private NetworkProxyConfiguration readNetworkProxyConfiguration( String prefix, Registry registry )
1244        {
1245            NetworkProxyConfiguration value = new NetworkProxyConfiguration();
1246    
1247        //String id = registry.getString( prefix + "id", value.getId() );
1248    
1249        List<String> idList = registry.getList( prefix + "id" );
1250        String id = value.getId();
1251        if (idList != null && !idList.isEmpty() )
1252        {
1253            StringBuilder sb = new StringBuilder(  );
1254            for (int i = 0,size = idList.size();i<size;i++)
1255            {
1256                sb.append( idList.get( i ) );
1257                if (i<size - 1)
1258                {
1259                    sb.append( ',' );
1260                }
1261            }
1262            id = sb.toString();
1263        }
1264    
1265            value.setId( id );
1266        //String protocol = registry.getString( prefix + "protocol", value.getProtocol() );
1267    
1268        List<String> protocolList = registry.getList( prefix + "protocol" );
1269        String protocol = value.getProtocol();
1270        if (protocolList != null && !protocolList.isEmpty() )
1271        {
1272            StringBuilder sb = new StringBuilder(  );
1273            for (int i = 0,size = protocolList.size();i<size;i++)
1274            {
1275                sb.append( protocolList.get( i ) );
1276                if (i<size - 1)
1277                {
1278                    sb.append( ',' );
1279                }
1280            }
1281            protocol = sb.toString();
1282        }
1283    
1284            value.setProtocol( protocol );
1285        //String host = registry.getString( prefix + "host", value.getHost() );
1286    
1287        List<String> hostList = registry.getList( prefix + "host" );
1288        String host = value.getHost();
1289        if (hostList != null && !hostList.isEmpty() )
1290        {
1291            StringBuilder sb = new StringBuilder(  );
1292            for (int i = 0,size = hostList.size();i<size;i++)
1293            {
1294                sb.append( hostList.get( i ) );
1295                if (i<size - 1)
1296                {
1297                    sb.append( ',' );
1298                }
1299            }
1300            host = sb.toString();
1301        }
1302    
1303            value.setHost( host );
1304        int port = registry.getInt( prefix + "port", value.getPort() );
1305            value.setPort( port );
1306        //String username = registry.getString( prefix + "username", value.getUsername() );
1307    
1308        List<String> usernameList = registry.getList( prefix + "username" );
1309        String username = value.getUsername();
1310        if (usernameList != null && !usernameList.isEmpty() )
1311        {
1312            StringBuilder sb = new StringBuilder(  );
1313            for (int i = 0,size = usernameList.size();i<size;i++)
1314            {
1315                sb.append( usernameList.get( i ) );
1316                if (i<size - 1)
1317                {
1318                    sb.append( ',' );
1319                }
1320            }
1321            username = sb.toString();
1322        }
1323    
1324            value.setUsername( username );
1325        //String password = registry.getString( prefix + "password", value.getPassword() );
1326    
1327        List<String> passwordList = registry.getList( prefix + "password" );
1328        String password = value.getPassword();
1329        if (passwordList != null && !passwordList.isEmpty() )
1330        {
1331            StringBuilder sb = new StringBuilder(  );
1332            for (int i = 0,size = passwordList.size();i<size;i++)
1333            {
1334                sb.append( passwordList.get( i ) );
1335                if (i<size - 1)
1336                {
1337                    sb.append( ',' );
1338                }
1339            }
1340            password = sb.toString();
1341        }
1342    
1343            value.setPassword( password );
1344            boolean useNtlm = registry.getBoolean( prefix + "useNtlm", value.isUseNtlm() );
1345            value.setUseNtlm( useNtlm );
1346    
1347            return value;
1348        }
1349        
1350        private RepositoryScanningConfiguration readRepositoryScanningConfiguration( String prefix, Registry registry )
1351        {
1352            RepositoryScanningConfiguration value = new RepositoryScanningConfiguration();
1353    
1354            java.util.List fileTypes = new java.util.ArrayList/*<FileType>*/();
1355            List fileTypesSubsets = registry.getSubsetList( prefix + "fileTypes.fileType" );
1356            for ( Iterator i = fileTypesSubsets.iterator(); i.hasNext(); )
1357            {
1358                FileType v = readFileType( "", (Registry) i.next() );
1359                fileTypes.add( v );
1360            }
1361            value.setFileTypes( fileTypes );
1362            java.util.List knownContentConsumers = new java.util.ArrayList/*<String>*/();
1363            knownContentConsumers.addAll( registry.getList( prefix + "knownContentConsumers.knownContentConsumer" ) );
1364            value.setKnownContentConsumers( knownContentConsumers );
1365            java.util.List invalidContentConsumers = new java.util.ArrayList/*<String>*/();
1366            invalidContentConsumers.addAll( registry.getList( prefix + "invalidContentConsumers.invalidContentConsumer" ) );
1367            value.setInvalidContentConsumers( invalidContentConsumers );
1368    
1369            return value;
1370        }
1371        
1372        private FileType readFileType( String prefix, Registry registry )
1373        {
1374            FileType value = new FileType();
1375    
1376        //String id = registry.getString( prefix + "id", value.getId() );
1377    
1378        List<String> idList = registry.getList( prefix + "id" );
1379        String id = value.getId();
1380        if (idList != null && !idList.isEmpty() )
1381        {
1382            StringBuilder sb = new StringBuilder(  );
1383            for (int i = 0,size = idList.size();i<size;i++)
1384            {
1385                sb.append( idList.get( i ) );
1386                if (i<size - 1)
1387                {
1388                    sb.append( ',' );
1389                }
1390            }
1391            id = sb.toString();
1392        }
1393    
1394            value.setId( id );
1395            java.util.List patterns = new java.util.ArrayList/*<String>*/();
1396            patterns.addAll( registry.getList( prefix + "patterns.pattern" ) );
1397            value.setPatterns( patterns );
1398    
1399            return value;
1400        }
1401        
1402        private OrganisationInformation readOrganisationInformation( String prefix, Registry registry )
1403        {
1404            OrganisationInformation value = new OrganisationInformation();
1405    
1406        //String name = registry.getString( prefix + "name", value.getName() );
1407    
1408        List<String> nameList = registry.getList( prefix + "name" );
1409        String name = value.getName();
1410        if (nameList != null && !nameList.isEmpty() )
1411        {
1412            StringBuilder sb = new StringBuilder(  );
1413            for (int i = 0,size = nameList.size();i<size;i++)
1414            {
1415                sb.append( nameList.get( i ) );
1416                if (i<size - 1)
1417                {
1418                    sb.append( ',' );
1419                }
1420            }
1421            name = sb.toString();
1422        }
1423    
1424            value.setName( name );
1425        //String url = registry.getString( prefix + "url", value.getUrl() );
1426    
1427        List<String> urlList = registry.getList( prefix + "url" );
1428        String url = value.getUrl();
1429        if (urlList != null && !urlList.isEmpty() )
1430        {
1431            StringBuilder sb = new StringBuilder(  );
1432            for (int i = 0,size = urlList.size();i<size;i++)
1433            {
1434                sb.append( urlList.get( i ) );
1435                if (i<size - 1)
1436                {
1437                    sb.append( ',' );
1438                }
1439            }
1440            url = sb.toString();
1441        }
1442    
1443            value.setUrl( url );
1444        //String logoLocation = registry.getString( prefix + "logoLocation", value.getLogoLocation() );
1445    
1446        List<String> logoLocationList = registry.getList( prefix + "logoLocation" );
1447        String logoLocation = value.getLogoLocation();
1448        if (logoLocationList != null && !logoLocationList.isEmpty() )
1449        {
1450            StringBuilder sb = new StringBuilder(  );
1451            for (int i = 0,size = logoLocationList.size();i<size;i++)
1452            {
1453                sb.append( logoLocationList.get( i ) );
1454                if (i<size - 1)
1455                {
1456                    sb.append( ',' );
1457                }
1458            }
1459            logoLocation = sb.toString();
1460        }
1461    
1462            value.setLogoLocation( logoLocation );
1463    
1464            return value;
1465        }
1466        
1467        private WebappConfiguration readWebappConfiguration( String prefix, Registry registry )
1468        {
1469            WebappConfiguration value = new WebappConfiguration();
1470    
1471            UserInterfaceOptions ui = readUserInterfaceOptions( prefix + "ui.", registry );
1472            value.setUi( ui );
1473    
1474            return value;
1475        }
1476        
1477        private UserInterfaceOptions readUserInterfaceOptions( String prefix, Registry registry )
1478        {
1479            UserInterfaceOptions value = new UserInterfaceOptions();
1480    
1481            boolean showFindArtifacts = registry.getBoolean( prefix + "showFindArtifacts", value.isShowFindArtifacts() );
1482            value.setShowFindArtifacts( showFindArtifacts );
1483            boolean appletFindEnabled = registry.getBoolean( prefix + "appletFindEnabled", value.isAppletFindEnabled() );
1484            value.setAppletFindEnabled( appletFindEnabled );
1485            boolean disableEasterEggs = registry.getBoolean( prefix + "disableEasterEggs", value.isDisableEasterEggs() );
1486            value.setDisableEasterEggs( disableEasterEggs );
1487        //String applicationUrl = registry.getString( prefix + "applicationUrl", value.getApplicationUrl() );
1488    
1489        List<String> applicationUrlList = registry.getList( prefix + "applicationUrl" );
1490        String applicationUrl = value.getApplicationUrl();
1491        if (applicationUrlList != null && !applicationUrlList.isEmpty() )
1492        {
1493            StringBuilder sb = new StringBuilder(  );
1494            for (int i = 0,size = applicationUrlList.size();i<size;i++)
1495            {
1496                sb.append( applicationUrlList.get( i ) );
1497                if (i<size - 1)
1498                {
1499                    sb.append( ',' );
1500                }
1501            }
1502            applicationUrl = sb.toString();
1503        }
1504    
1505            value.setApplicationUrl( applicationUrl );
1506            boolean disableRegistration = registry.getBoolean( prefix + "disableRegistration", value.isDisableRegistration() );
1507            value.setDisableRegistration( disableRegistration );
1508    
1509            return value;
1510        }
1511        
1512        private NetworkConfiguration readNetworkConfiguration( String prefix, Registry registry )
1513        {
1514            NetworkConfiguration value = new NetworkConfiguration();
1515    
1516        int maxTotal = registry.getInt( prefix + "maxTotal", value.getMaxTotal() );
1517            value.setMaxTotal( maxTotal );
1518        int maxTotalPerHost = registry.getInt( prefix + "maxTotalPerHost", value.getMaxTotalPerHost() );
1519            value.setMaxTotalPerHost( maxTotalPerHost );
1520            boolean usePooling = registry.getBoolean( prefix + "usePooling", value.isUsePooling() );
1521            value.setUsePooling( usePooling );
1522    
1523            return value;
1524        }
1525        
1526        private ArchivaRuntimeConfiguration readArchivaRuntimeConfiguration( String prefix, Registry registry )
1527        {
1528            ArchivaRuntimeConfiguration value = new ArchivaRuntimeConfiguration();
1529    
1530            CacheConfiguration urlFailureCacheConfiguration = readCacheConfiguration( prefix + "urlFailureCacheConfiguration.", registry );
1531            value.setUrlFailureCacheConfiguration( urlFailureCacheConfiguration );
1532    
1533            return value;
1534        }
1535        
1536        private RedbackRuntimeConfiguration readRedbackRuntimeConfiguration( String prefix, Registry registry )
1537        {
1538            RedbackRuntimeConfiguration value = new RedbackRuntimeConfiguration();
1539    
1540            boolean migratedFromRedbackConfiguration = registry.getBoolean( prefix + "migratedFromRedbackConfiguration", value.isMigratedFromRedbackConfiguration() );
1541            value.setMigratedFromRedbackConfiguration( migratedFromRedbackConfiguration );
1542            java.util.List userManagerImpls = new java.util.ArrayList/*<String>*/();
1543            userManagerImpls.addAll( registry.getList( prefix + "userManagerImpls.userManagerImpl" ) );
1544            value.setUserManagerImpls( userManagerImpls );
1545            java.util.List rbacManagerImpls = new java.util.ArrayList/*<String>*/();
1546            rbacManagerImpls.addAll( registry.getList( prefix + "rbacManagerImpls.rbacManagerImpl" ) );
1547            value.setRbacManagerImpls( rbacManagerImpls );
1548            LdapConfiguration ldapConfiguration = readLdapConfiguration( prefix + "ldapConfiguration.", registry );
1549            value.setLdapConfiguration( ldapConfiguration );
1550            java.util.List ldapGroupMappings = new java.util.ArrayList/*<LdapGroupMapping>*/();
1551            List ldapGroupMappingsSubsets = registry.getSubsetList( prefix + "ldapGroupMappings.ldapGroupMapping" );
1552            for ( Iterator i = ldapGroupMappingsSubsets.iterator(); i.hasNext(); )
1553            {
1554                LdapGroupMapping v = readLdapGroupMapping( "", (Registry) i.next() );
1555                ldapGroupMappings.add( v );
1556            }
1557            value.setLdapGroupMappings( ldapGroupMappings );
1558            java.util.Map configurationProperties = registry.getProperties( prefix + "configurationProperties" );
1559            value.setConfigurationProperties( configurationProperties );
1560            boolean useUsersCache = registry.getBoolean( prefix + "useUsersCache", value.isUseUsersCache() );
1561            value.setUseUsersCache( useUsersCache );
1562            CacheConfiguration usersCacheConfiguration = readCacheConfiguration( prefix + "usersCacheConfiguration.", registry );
1563            value.setUsersCacheConfiguration( usersCacheConfiguration );
1564    
1565            return value;
1566        }
1567        
1568        private LdapConfiguration readLdapConfiguration( String prefix, Registry registry )
1569        {
1570            LdapConfiguration value = new LdapConfiguration();
1571    
1572        //String hostName = registry.getString( prefix + "hostName", value.getHostName() );
1573    
1574        List<String> hostNameList = registry.getList( prefix + "hostName" );
1575        String hostName = value.getHostName();
1576        if (hostNameList != null && !hostNameList.isEmpty() )
1577        {
1578            StringBuilder sb = new StringBuilder(  );
1579            for (int i = 0,size = hostNameList.size();i<size;i++)
1580            {
1581                sb.append( hostNameList.get( i ) );
1582                if (i<size - 1)
1583                {
1584                    sb.append( ',' );
1585                }
1586            }
1587            hostName = sb.toString();
1588        }
1589    
1590            value.setHostName( hostName );
1591        int port = registry.getInt( prefix + "port", value.getPort() );
1592            value.setPort( port );
1593            boolean ssl = registry.getBoolean( prefix + "ssl", value.isSsl() );
1594            value.setSsl( ssl );
1595        //String baseDn = registry.getString( prefix + "baseDn", value.getBaseDn() );
1596    
1597        List<String> baseDnList = registry.getList( prefix + "baseDn" );
1598        String baseDn = value.getBaseDn();
1599        if (baseDnList != null && !baseDnList.isEmpty() )
1600        {
1601            StringBuilder sb = new StringBuilder(  );
1602            for (int i = 0,size = baseDnList.size();i<size;i++)
1603            {
1604                sb.append( baseDnList.get( i ) );
1605                if (i<size - 1)
1606                {
1607                    sb.append( ',' );
1608                }
1609            }
1610            baseDn = sb.toString();
1611        }
1612    
1613            value.setBaseDn( baseDn );
1614        //String baseGroupsDn = registry.getString( prefix + "baseGroupsDn", value.getBaseGroupsDn() );
1615    
1616        List<String> baseGroupsDnList = registry.getList( prefix + "baseGroupsDn" );
1617        String baseGroupsDn = value.getBaseGroupsDn();
1618        if (baseGroupsDnList != null && !baseGroupsDnList.isEmpty() )
1619        {
1620            StringBuilder sb = new StringBuilder(  );
1621            for (int i = 0,size = baseGroupsDnList.size();i<size;i++)
1622            {
1623                sb.append( baseGroupsDnList.get( i ) );
1624                if (i<size - 1)
1625                {
1626                    sb.append( ',' );
1627                }
1628            }
1629            baseGroupsDn = sb.toString();
1630        }
1631    
1632            value.setBaseGroupsDn( baseGroupsDn );
1633        //String contextFactory = registry.getString( prefix + "contextFactory", value.getContextFactory() );
1634    
1635        List<String> contextFactoryList = registry.getList( prefix + "contextFactory" );
1636        String contextFactory = value.getContextFactory();
1637        if (contextFactoryList != null && !contextFactoryList.isEmpty() )
1638        {
1639            StringBuilder sb = new StringBuilder(  );
1640            for (int i = 0,size = contextFactoryList.size();i<size;i++)
1641            {
1642                sb.append( contextFactoryList.get( i ) );
1643                if (i<size - 1)
1644                {
1645                    sb.append( ',' );
1646                }
1647            }
1648            contextFactory = sb.toString();
1649        }
1650    
1651            value.setContextFactory( contextFactory );
1652        //String bindDn = registry.getString( prefix + "bindDn", value.getBindDn() );
1653    
1654        List<String> bindDnList = registry.getList( prefix + "bindDn" );
1655        String bindDn = value.getBindDn();
1656        if (bindDnList != null && !bindDnList.isEmpty() )
1657        {
1658            StringBuilder sb = new StringBuilder(  );
1659            for (int i = 0,size = bindDnList.size();i<size;i++)
1660            {
1661                sb.append( bindDnList.get( i ) );
1662                if (i<size - 1)
1663                {
1664                    sb.append( ',' );
1665                }
1666            }
1667            bindDn = sb.toString();
1668        }
1669    
1670            value.setBindDn( bindDn );
1671        //String password = registry.getString( prefix + "password", value.getPassword() );
1672    
1673        List<String> passwordList = registry.getList( prefix + "password" );
1674        String password = value.getPassword();
1675        if (passwordList != null && !passwordList.isEmpty() )
1676        {
1677            StringBuilder sb = new StringBuilder(  );
1678            for (int i = 0,size = passwordList.size();i<size;i++)
1679            {
1680                sb.append( passwordList.get( i ) );
1681                if (i<size - 1)
1682                {
1683                    sb.append( ',' );
1684                }
1685            }
1686            password = sb.toString();
1687        }
1688    
1689            value.setPassword( password );
1690        //String authenticationMethod = registry.getString( prefix + "authenticationMethod", value.getAuthenticationMethod() );
1691    
1692        List<String> authenticationMethodList = registry.getList( prefix + "authenticationMethod" );
1693        String authenticationMethod = value.getAuthenticationMethod();
1694        if (authenticationMethodList != null && !authenticationMethodList.isEmpty() )
1695        {
1696            StringBuilder sb = new StringBuilder(  );
1697            for (int i = 0,size = authenticationMethodList.size();i<size;i++)
1698            {
1699                sb.append( authenticationMethodList.get( i ) );
1700                if (i<size - 1)
1701                {
1702                    sb.append( ',' );
1703                }
1704            }
1705            authenticationMethod = sb.toString();
1706        }
1707    
1708            value.setAuthenticationMethod( authenticationMethod );
1709            boolean bindAuthenticatorEnabled = registry.getBoolean( prefix + "bindAuthenticatorEnabled", value.isBindAuthenticatorEnabled() );
1710            value.setBindAuthenticatorEnabled( bindAuthenticatorEnabled );
1711            boolean writable = registry.getBoolean( prefix + "writable", value.isWritable() );
1712            value.setWritable( writable );
1713            boolean useRoleNameAsGroup = registry.getBoolean( prefix + "useRoleNameAsGroup", value.isUseRoleNameAsGroup() );
1714            value.setUseRoleNameAsGroup( useRoleNameAsGroup );
1715            java.util.Map extraProperties = registry.getProperties( prefix + "extraProperties" );
1716            value.setExtraProperties( extraProperties );
1717    
1718            return value;
1719        }
1720        
1721        private CacheConfiguration readCacheConfiguration( String prefix, Registry registry )
1722        {
1723            CacheConfiguration value = new CacheConfiguration();
1724    
1725        int timeToIdleSeconds = registry.getInt( prefix + "timeToIdleSeconds", value.getTimeToIdleSeconds() );
1726            value.setTimeToIdleSeconds( timeToIdleSeconds );
1727        int timeToLiveSeconds = registry.getInt( prefix + "timeToLiveSeconds", value.getTimeToLiveSeconds() );
1728            value.setTimeToLiveSeconds( timeToLiveSeconds );
1729        int maxElementsInMemory = registry.getInt( prefix + "maxElementsInMemory", value.getMaxElementsInMemory() );
1730            value.setMaxElementsInMemory( maxElementsInMemory );
1731        int maxElementsOnDisk = registry.getInt( prefix + "maxElementsOnDisk", value.getMaxElementsOnDisk() );
1732            value.setMaxElementsOnDisk( maxElementsOnDisk );
1733    
1734            return value;
1735        }
1736        
1737        private LdapGroupMapping readLdapGroupMapping( String prefix, Registry registry )
1738        {
1739            LdapGroupMapping value = new LdapGroupMapping();
1740    
1741        //String group = registry.getString( prefix + "group", value.getGroup() );
1742    
1743        List<String> groupList = registry.getList( prefix + "group" );
1744        String group = value.getGroup();
1745        if (groupList != null && !groupList.isEmpty() )
1746        {
1747            StringBuilder sb = new StringBuilder(  );
1748            for (int i = 0,size = groupList.size();i<size;i++)
1749            {
1750                sb.append( groupList.get( i ) );
1751                if (i<size - 1)
1752                {
1753                    sb.append( ',' );
1754                }
1755            }
1756            group = sb.toString();
1757        }
1758    
1759            value.setGroup( group );
1760            java.util.List roleNames = new java.util.ArrayList/*<String>*/();
1761            roleNames.addAll( registry.getList( prefix + "roleNames.roleName" ) );
1762            value.setRoleNames( roleNames );
1763    
1764            return value;
1765        }
1766        
1767    }