source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.metadata.repository.cassandra;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.google.common.base.Function;
  23 import com.google.common.base.Predicate;
  24 import com.google.common.collect.Iterables;
  25 import com.netflix.astyanax.entitystore.EntityManager;
  26 import net.sf.beanlib.provider.replicator.BeanReplicator;
  27 import org.apache.archiva.configuration.ArchivaConfiguration;
  28 import org.apache.archiva.metadata.model.ArtifactMetadata;
  29 import org.apache.archiva.metadata.model.FacetedMetadata;
  30 import org.apache.archiva.metadata.model.MetadataFacet;
  31 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  32 import org.apache.archiva.metadata.model.ProjectMetadata;
  33 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  34 import org.apache.archiva.metadata.model.ProjectVersionReference;
  35 import org.apache.archiva.metadata.repository.MetadataRepository;
  36 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  37 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  38 import org.apache.archiva.metadata.repository.cassandra.model.ArtifactMetadataModel;
  39 import org.apache.archiva.metadata.repository.cassandra.model.MetadataFacetModel;
  40 import org.apache.archiva.metadata.repository.cassandra.model.Namespace;
  41 import org.apache.archiva.metadata.repository.cassandra.model.Project;
  42 import org.apache.archiva.metadata.repository.cassandra.model.ProjectVersionMetadataModel;
  43 import org.apache.archiva.metadata.repository.cassandra.model.Repository;
  44 import org.apache.commons.lang.StringUtils;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 import javax.persistence.PersistenceException;
  49 import java.util.ArrayList;
  50 import java.util.Collection;
  51 import java.util.Collections;
  52 import java.util.Date;
  53 import java.util.HashMap;
  54 import java.util.HashSet;
  55 import java.util.Iterator;
  56 import java.util.List;
  57 import java.util.Map;
  58 import java.util.Set;
  59
  60 /**
  61  * @author Olivier Lamy
  62  * @since 2.0.0
  63  */
  64 public class CassandraMetadataRepository
  65     implements MetadataRepository
  66 {
  67
  68     private Logger logger = LoggerFactory.getLogger( getClass() );
  69
  70     private ArchivaConfiguration configuration;
  71
  72     private final Map<String, MetadataFacetFactory> metadataFacetFactories;
  73
  74     private CassandraEntityManagerFactory cassandraEntityManagerFactory;
  75
  76     public CassandraMetadataRepository( Map<String, MetadataFacetFactory> metadataFacetFactories,
  77                                         ArchivaConfiguration configuration,
  78                                         CassandraEntityManagerFactory cassandraEntityManagerFactory )
  79     {
  80         this.metadataFacetFactories = metadataFacetFactories;
  81         this.configuration = configuration;
  82         this.cassandraEntityManagerFactory = cassandraEntityManagerFactory;
  83     }
  84
  85
  86     public EntityManager<Repository, String> getRepositoryEntityManager()
  87     {
  88         return this.cassandraEntityManagerFactory.getRepositoryEntityManager();
  89     }
  90
  91     public EntityManager<Namespace, String> getNamespaceEntityManager()
  92     {
  93         return this.cassandraEntityManagerFactory.getNamespaceEntityManager();
  94     }
  95
  96     public EntityManager<Project, String> getProjectEntityManager()
  97     {
  98         return this.cassandraEntityManagerFactory.getProjectEntityManager();
  99     }
 100
 101     public EntityManager<ArtifactMetadataModel, String> getArtifactMetadataModelEntityManager()
 102     {
 103         return cassandraEntityManagerFactory.getArtifactMetadataModelEntityManager();
 104     }
 105
 106     public EntityManager<MetadataFacetModel, String> getMetadataFacetModelEntityManager()
 107     {
 108         return this.cassandraEntityManagerFactory.getMetadataFacetModelEntityManager();
 109     }
 110
 111     public EntityManager<ProjectVersionMetadataModel, String> getProjectVersionMetadataModelEntityManager()
 112     {
 113         return this.cassandraEntityManagerFactory.getProjectVersionMetadataModelEntityManager();
 114     }
 115
 116     @Override
 117     public void updateNamespace( String repositoryId, String namespaceId )
 118         throws MetadataRepositoryException
 119     {
 120         updateOrAddNamespace( repositoryId, namespaceId );
 121
 122     }
 123
 124     public Namespace updateOrAddNamespace( String repositoryId, String namespaceId )
 125         throws MetadataRepositoryException
 126     {
 127         try
 128         {
 129             Repository repository = this.getRepositoryEntityManager().get( repositoryId );
 130
 131             if ( repository == null )
 132             {
 133                 repository = new Repository( repositoryId );
 134
 135                 Namespace namespace = new Namespace( namespaceId, repository );
 136                 this.getRepositoryEntityManager().put( repository );
 137
 138                 this.getNamespaceEntityManager().put( namespace );
 139             }
 140             // FIXME add a Namespace id builder
 141             Namespace namespace = getNamespaceEntityManager().get(
 142                 new Namespace.KeyBuilder().withNamespace( namespaceId ).withRepositoryId( repositoryId ).build() );
 143             if ( namespace == null )
 144             {
 145                 namespace = new Namespace( namespaceId, repository );
 146                 getNamespaceEntityManager().put( namespace );
 147             }
 148             return namespace;
 149         }
 150         catch ( PersistenceException e )
 151         {
 152             throw new MetadataRepositoryException( e.getMessage(), e );
 153         }
 154
 155     }
 156
 157
 158     @Override
 159     public void removeNamespace( String repositoryId, String namespaceId )
 160         throws MetadataRepositoryException
 161     {
 162         try
 163         {
 164             Namespace namespace = getNamespaceEntityManager().get(
 165                 new Namespace.KeyBuilder().withNamespace( namespaceId ).withRepositoryId( repositoryId ).build() );
 166             if ( namespace != null )
 167             {
 168                 getNamespaceEntityManager().remove( namespace );
 169             }
 170         }
 171         catch ( PersistenceException e )
 172         {
 173             throw new MetadataRepositoryException( e.getMessage(), e );
 174         }
 175     }
 176
 177
 178     @Override
 179     public void removeRepository( final String repositoryId )
 180         throws MetadataRepositoryException
 181     {
 182         try
 183         {
 184             final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
 185
 186             // remove data related to the repository
 187             this.getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 188             {
 189                 @Override
 190                 public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 191                 {
 192                     if ( artifactMetadataModel != null )
 193                     {
 194                         if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId ) )
 195                         {
 196                             artifactMetadataModels.add( artifactMetadataModel );
 197                         }
 198                     }
 199                     return Boolean.TRUE;
 200                 }
 201             } );
 202
 203             getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
 204
 205             final List<Namespace> namespaces = new ArrayList<Namespace>();
 206
 207             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 208             {
 209                 @Override
 210                 public Boolean apply( Namespace namespace )
 211                 {
 212                     if ( namespace != null )
 213                     {
 214                         if ( StringUtils.equals( namespace.getRepository().getId(), repositoryId ) )
 215                         {
 216                             namespaces.add( namespace );
 217                         }
 218                     }
 219                     return Boolean.TRUE;
 220                 }
 221             } );
 222
 223             getNamespaceEntityManager().remove( namespaces );
 224
 225             final List<Project> projects = new ArrayList<Project>();
 226             getProjectEntityManager().visitAll( new Function<Project, Boolean>()
 227             {
 228                 @Override
 229                 public Boolean apply( Project project )
 230                 {
 231                     if ( project != null )
 232                     {
 233                         if ( StringUtils.equals( project.getNamespace().getRepository().getId(), repositoryId ) )
 234                         {
 235                             projects.add( project );
 236                         }
 237                     }
 238                     return Boolean.TRUE;
 239                 }
 240             } );
 241
 242             getProjectEntityManager().remove( projects );
 243
 244             // TODO  cleanup or not
 245             //final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>(  );
 246             //getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 247
 248             final List<ProjectVersionMetadataModel> projectVersionMetadataModels =
 249                 new ArrayList<ProjectVersionMetadataModel>();
 250
 251             getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 252             {
 253                 @Override
 254                 public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 255                 {
 256                     if ( projectVersionMetadataModel != null )
 257                     {
 258                         if ( StringUtils.equals( projectVersionMetadataModel.getNamespace().getRepository().getId(),
 259                                                  repositoryId ) )
 260                         {
 261                             projectVersionMetadataModels.add( projectVersionMetadataModel );
 262                         }
 263                     }
 264                     return Boolean.TRUE;
 265                 }
 266             } );
 267
 268             getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModels );
 269
 270             Repository repository = getRepositoryEntityManager().get( repositoryId );
 271             if ( repository != null )
 272             {
 273                 getRepositoryEntityManager().remove( repository );
 274             }
 275
 276         }
 277         catch ( PersistenceException e )
 278         {
 279             throw new MetadataRepositoryException( e.getMessage(), e );
 280         }
 281     }
 282
 283     @Override
 284     public Collection<String> getRepositories()
 285         throws MetadataRepositoryException
 286     {
 287         try
 288         {
 289             logger.debug( "getRepositories" );
 290
 291             List<Repository> repositories = getRepositoryEntityManager().getAll();
 292             if ( repositories == null )
 293             {
 294                 return Collections.emptyList();
 295             }
 296             List<String> repoIds = new ArrayList<String>( repositories.size() );
 297             for ( Repository repository : repositories )
 298             {
 299                 repoIds.add( repository.getName() );
 300             }
 301             logger.debug( "getRepositories found: {}", repoIds );
 302             return repoIds;
 303         }
 304         catch ( PersistenceException e )
 305         {
 306             throw new MetadataRepositoryException( e.getMessage(), e );
 307         }
 308
 309     }
 310
 311
 312     @Override
 313     public Collection<String> getRootNamespaces( final String repoId )
 314         throws MetadataResolutionException
 315     {
 316         try
 317         {
 318
 319             //final List<Namespace> namespaceList =
 320             //    getNamespaceEntityManager().find( "SELECT name FROM namespace WHERE repository.id='"+ repoId + "'" );
 321
 322             //final Set<String> namespaces = new HashSet<String>( namespaceList.size() );
 323
 324             final Set<String> namespaces = new HashSet<String>( );
 325
 326             /*
 327             for ( Namespace namespace : namespaceList )
 328             {
 329                 String name = namespace.getName();
 330                 if ( StringUtils.isNotEmpty( name ) )
 331                 {
 332                     namespaces.add( StringUtils.substringBefore( name, "." ) );
 333                 }
 334             }
 335             */
 336
 337
 338             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 339             {
 340                 // @Nullable add dependency ?
 341                 @Override
 342                 public Boolean apply( Namespace namespace )
 343                 {
 344                     if ( namespace != null && namespace.getRepository() != null
 345                         && StringUtils.equalsIgnoreCase( repoId, namespace.getRepository().getId() ) )
 346                     {
 347                         String name = namespace.getName();
 348                         if ( StringUtils.isNotEmpty( name ) )
 349                         {
 350                             namespaces.add( StringUtils.substringBefore( name, "." ) );
 351                         }
 352                     }
 353                     return Boolean.TRUE;
 354                 }
 355             } );
 356
 357             return namespaces;
 358         }
 359         catch ( PersistenceException e )
 360         {
 361             throw new MetadataResolutionException( e.getMessage(), e );
 362         }
 363     }
 364
 365     @Override
 366     public Collection<String> getNamespaces( final String repoId, final String namespaceId )
 367         throws MetadataResolutionException
 368     {
 369         try
 370         {
 371             final Set<String> namespaces = new HashSet<String>();
 372
 373             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 374             {
 375                 // @Nullable add dependency ?
 376                 @Override
 377                 public Boolean apply( Namespace namespace )
 378                 {
 379                     if ( namespace != null && namespace.getRepository() != null && StringUtils.equalsIgnoreCase( repoId,
 380                                                                                                                  namespace.getRepository().getId() ) )
 381                     {
 382                         String currentNamespace = namespace.getName();
 383                         // we only return childs
 384                         if ( StringUtils.startsWith( currentNamespace, namespaceId ) && (
 385                             StringUtils.length( currentNamespace ) > StringUtils.length( namespaceId ) ) )
 386                         {
 387                             // store after namespaceId '.' but before next '.'
 388                             // call org namespace org.apache.maven.shared -> stored apache
 389
 390                             String calledNamespace =
 391                                 StringUtils.endsWith( namespaceId, "." ) ? namespaceId : namespaceId + ".";
 392                             String storedNamespace = StringUtils.substringAfter( currentNamespace, calledNamespace );
 393
 394                             storedNamespace = StringUtils.substringBefore( storedNamespace, "." );
 395
 396                             namespaces.add( storedNamespace );
 397                         }
 398                     }
 399                     return Boolean.TRUE;
 400                 }
 401             } );
 402
 403             return namespaces;
 404         }
 405         catch ( PersistenceException e )
 406         {
 407             throw new MetadataResolutionException( e.getMessage(), e );
 408         }
 409
 410     }
 411
 412     public List<String> getNamespaces( final String repoId )
 413         throws MetadataResolutionException
 414     {
 415         try
 416         {
 417             logger.debug( "getNamespaces for repository '{}'", repoId );
 418             //TypedQuery<Repository> typedQuery =
 419             //    entityManager.createQuery( "select n from Namespace n where n.repository_id=:id", Namespace.class );
 420
 421             //List<Repository> namespaces = typedQuery.setParameter( "id", repoId ).getResultList();
 422
 423             Repository repository = getRepositoryEntityManager().get( repoId );
 424
 425             if ( repository == null )
 426             {
 427                 return Collections.emptyList();
 428             }
 429
 430             // FIXME find correct cql query
 431             //String query = "select * from namespace where repository.id = '" + repoId + "';";
 432
 433             //List<Namespace> namespaces = getNamespaceEntityManager().find( query );
 434
 435             //final Set<Namespace> namespaces = new HashSet<Namespace>();
 436             final Set<String> namespaces = new HashSet<String>();
 437
 438             getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 439             {
 440                 // @Nullable add dependency ?
 441                 @Override
 442                 public Boolean apply( Namespace namespace )
 443                 {
 444                     if ( namespace != null && namespace.getRepository() != null && StringUtils.equalsIgnoreCase( repoId,
 445                                                                                                                  namespace.getRepository().getId() ) )
 446                     {
 447                         namespaces.add( namespace.getId() );
 448                     }
 449                     return Boolean.TRUE;
 450                 }
 451             } );
 452
 453
 454             /*
 455
 456             repository.setNamespaces( new ArrayList<Namespace>( namespaces ) );
 457             if ( repository == null || repository.getNamespaces().isEmpty() )
 458             {
 459                 return Collections.emptyList();
 460             }
 461
 462             List<String> namespaceIds = new ArrayList<String>( repository.getNamespaces().size() );
 463
 464             for ( Namespace n : repository.getNamespaces() )
 465             {
 466                 namespaceIds.add( n.getName() );
 467             }
 468
 469             logger.debug( "getNamespaces for repository '{}' found {}", repoId, namespaceIds.size() );
 470
 471             return namespaceIds;
 472             */
 473             return new ArrayList<String>( namespaces );
 474         }
 475         catch ( PersistenceException e )
 476         {
 477             throw new MetadataResolutionException( e.getMessage(), e );
 478         }
 479     }
 480
 481
 482     @Override
 483     public void updateProject( String repositoryId, ProjectMetadata projectMetadata )
 484         throws MetadataRepositoryException
 485     {
 486
 487         // project exists ? if yes return
 488         String projectKey = new Project.KeyBuilder().withProjectId( projectMetadata.getId() ).withNamespace(
 489             new Namespace( projectMetadata.getNamespace(), new Repository( repositoryId ) ) ).build();
 490
 491         Project project = getProjectEntityManager().get( projectKey );
 492         if ( project != null )
 493         {
 494             return;
 495         }
 496
 497         String namespaceKey = new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace(
 498             projectMetadata.getNamespace() ).build();
 499         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 500         if ( namespace == null )
 501         {
 502             namespace = updateOrAddNamespace( repositoryId, projectMetadata.getNamespace() );
 503         }
 504
 505         project = new Project( projectKey, projectMetadata.getId(), namespace );
 506
 507         try
 508         {
 509             getProjectEntityManager().put( project );
 510         }
 511         catch ( PersistenceException e )
 512         {
 513             throw new MetadataRepositoryException( e.getMessage(), e );
 514         }
 515
 516     }
 517
 518     @Override
 519     public void removeProject( final String repositoryId, final String namespaceId, final String projectId )
 520         throws MetadataRepositoryException
 521     {
 522
 523         // cleanup ArtifactMetadataModel
 524         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
 525
 526         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 527         {
 528             @Override
 529             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 530             {
 531                 if ( artifactMetadataModel != null )
 532                 {
 533                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
 534                         && StringUtils.equals( artifactMetadataModel.getNamespace(), namespaceId )
 535                         && StringUtils.equals( artifactMetadataModel.getProject(), projectId ) )
 536                     {
 537                         artifactMetadataModels.add( artifactMetadataModel );
 538                     }
 539                 }
 540                 return Boolean.TRUE;
 541             }
 542         } );
 543
 544         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
 545
 546         Namespace namespace = new Namespace( namespaceId, new Repository( repositoryId ) );
 547
 548         final List<ProjectVersionMetadataModel> projectVersionMetadataModels =
 549             new ArrayList<ProjectVersionMetadataModel>();
 550
 551         getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 552         {
 553             @Override
 554             public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 555             {
 556                 if ( projectVersionMetadataModel != null )
 557                 {
 558                     if ( StringUtils.equals( repositoryId,
 559                                              projectVersionMetadataModel.getNamespace().getRepository().getName() )
 560                         && StringUtils.equals( namespaceId, projectVersionMetadataModel.getNamespace().getName() )
 561                         && StringUtils.equals( projectId, projectVersionMetadataModel.getProjectId() ) )
 562                     {
 563                         projectVersionMetadataModels.add( projectVersionMetadataModel );
 564                     }
 565                 }
 566                 return Boolean.TRUE;
 567             }
 568         } );
 569
 570         if ( !projectVersionMetadataModels.isEmpty() )
 571         {
 572             getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModels );
 573         }
 574
 575         String key = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 576
 577         Project project = getProjectEntityManager().get( key );
 578         if ( project == null )
 579         {
 580             logger.debug( "removeProject notfound" );
 581             return;
 582         }
 583         logger.debug( "removeProject {}", project );
 584
 585         getProjectEntityManager().remove( project );
 586     }
 587
 588     @Override
 589     public Collection<String> getProjectVersions( final String repoId, final String namespace, final String projectId )
 590         throws MetadataResolutionException
 591     {
 592         final Set<String> versions = new HashSet<String>();
 593         getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 594         {
 595             @Override
 596             public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 597             {
 598                 if ( projectVersionMetadataModel != null )
 599                 {
 600                     if ( StringUtils.equals( repoId,
 601                                              projectVersionMetadataModel.getNamespace().getRepository().getName() )
 602                         && StringUtils.startsWith( projectVersionMetadataModel.getNamespace().getName(), namespace )
 603                         && StringUtils.equals( projectId, projectVersionMetadataModel.getProjectId() ) )
 604                     {
 605                         versions.add( projectVersionMetadataModel.getId() );
 606                     }
 607                 }
 608                 return Boolean.TRUE;
 609             }
 610         } );
 611         // FIXME use cql query
 612         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 613         {
 614             @Override
 615             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 616             {
 617                 if ( artifactMetadataModel != null )
 618                 {
 619                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
 620                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
 621                                                                                                  artifactMetadataModel.getProject() ) )
 622                     {
 623                         versions.add( artifactMetadataModel.getProjectVersion() );
 624                     }
 625                 }
 626                 return Boolean.TRUE;
 627             }
 628         } );
 629
 630         return versions;
 631     }
 632
 633     @Override
 634     public void updateArtifact( String repositoryId, String namespaceId, String projectId, String projectVersion,
 635                                 ArtifactMetadata artifactMeta )
 636         throws MetadataRepositoryException
 637     {
 638         String namespaceKey =
 639             new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespaceId ).build();
 640         // create the namespace if not exists
 641         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 642         if ( namespace == null )
 643         {
 644             namespace = updateOrAddNamespace( repositoryId, namespaceId );
 645         }
 646
 647         // create the project if not exist
 648         String projectKey = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 649
 650         Project project = getProjectEntityManager().get( projectKey );
 651         if ( project == null )
 652         {
 653             project = new Project( projectKey, projectId, namespace );
 654             try
 655             {
 656                 getProjectEntityManager().put( project );
 657             }
 658             catch ( PersistenceException e )
 659             {
 660                 throw new MetadataRepositoryException( e.getMessage(), e );
 661             }
 662         }
 663
 664         String key = new ArtifactMetadataModel.KeyBuilder().withNamespace( namespace ).withProject( projectId ).withId(
 665             artifactMeta.getId() ).withProjectVersion( projectVersion ).build();
 666
 667         ArtifactMetadataModel artifactMetadataModel = getArtifactMetadataModelEntityManager().get( key );
 668         if ( artifactMetadataModel == null )
 669         {
 670             artifactMetadataModel = new ArtifactMetadataModel( key, artifactMeta.getId(), repositoryId, namespaceId,
 671                                                                artifactMeta.getProject(), projectVersion,
 672                                                                artifactMeta.getVersion(),
 673                                                                artifactMeta.getFileLastModified(),
 674                                                                artifactMeta.getSize(), artifactMeta.getMd5(),
 675                                                                artifactMeta.getSha1(), artifactMeta.getWhenGathered() );
 676
 677         }
 678         else
 679         {
 680             artifactMetadataModel.setFileLastModified( artifactMeta.getFileLastModified().getTime() );
 681             artifactMetadataModel.setWhenGathered( artifactMeta.getWhenGathered().getTime() );
 682             artifactMetadataModel.setSize( artifactMeta.getSize() );
 683             artifactMetadataModel.setMd5( artifactMeta.getMd5() );
 684             artifactMetadataModel.setSha1( artifactMeta.getSha1() );
 685             artifactMetadataModel.setVersion( artifactMeta.getVersion() );
 686         }
 687
 688         try
 689         {
 690             getArtifactMetadataModelEntityManager().put( artifactMetadataModel );
 691         }
 692         catch ( PersistenceException e )
 693         {
 694             throw new MetadataRepositoryException( e.getMessage(), e );
 695         }
 696
 697         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
 698             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
 699
 700         ProjectVersionMetadataModel projectVersionMetadataModel =
 701             getProjectVersionMetadataModelEntityManager().get( key );
 702
 703         if ( projectVersionMetadataModel == null )
 704         {
 705             projectVersionMetadataModel = new ProjectVersionMetadataModel();
 706             projectVersionMetadataModel.setRowId( key );
 707             projectVersionMetadataModel.setProjectId( projectId );
 708             projectVersionMetadataModel.setId( projectVersion );
 709             projectVersionMetadataModel.setNamespace( namespace );
 710
 711             getProjectVersionMetadataModelEntityManager().put( projectVersionMetadataModel );
 712
 713         }
 714
 715         // now facets
 716         updateFacets( artifactMeta, artifactMetadataModel );
 717
 718     }
 719
 720     @Override
 721     public Collection<String> getArtifactVersions( final String repoId, final String namespace, final String projectId,
 722                                                    final String projectVersion )
 723         throws MetadataResolutionException
 724     {
 725         final Set<String> versions = new HashSet<String>();
 726         // FIXME use cql query
 727         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 728         {
 729             @Override
 730             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 731             {
 732                 if ( artifactMetadataModel != null )
 733                 {
 734                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
 735                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
 736                                                                                                  artifactMetadataModel.getProject() )
 737                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
 738                     {
 739                         versions.add( artifactMetadataModel.getVersion() );
 740                     }
 741                 }
 742                 return Boolean.TRUE;
 743             }
 744         } );
 745
 746         return versions;
 747     }
 748
 749     /**
 750      * iterate over available facets to remove/add from the artifactMetadata
 751      *
 752      * @param facetedMetadata
 753      * @param artifactMetadataModel only use for the key
 754      */
 755     private void updateFacets( final FacetedMetadata facetedMetadata,
 756                                final ArtifactMetadataModel artifactMetadataModel )
 757     {
 758
 759         for ( final String facetId : metadataFacetFactories.keySet() )
 760         {
 761             MetadataFacet metadataFacet = facetedMetadata.getFacet( facetId );
 762             if ( metadataFacet == null )
 763             {
 764                 continue;
 765             }
 766             // clean first
 767
 768             final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
 769
 770             getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 771             {
 772                 @Override
 773                 public Boolean apply( MetadataFacetModel metadataFacetModel )
 774                 {
 775                     ArtifactMetadataModel tmp = metadataFacetModel.getArtifactMetadataModel();
 776                     if ( StringUtils.equals( metadataFacetModel.getFacetId(), facetId ) && StringUtils.equals(
 777                         tmp.getRepositoryId(), artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
 778                         tmp.getNamespace(), artifactMetadataModel.getNamespace() ) && StringUtils.equals(
 779                         tmp.getProject(), artifactMetadataModel.getProject() ) )
 780                     {
 781                         metadataFacetModels.add( metadataFacetModel );
 782                     }
 783                     return Boolean.TRUE;
 784                 }
 785             } );
 786
 787             getMetadataFacetModelEntityManager().remove( metadataFacetModels );
 788
 789             Map<String, String> properties = metadataFacet.toProperties();
 790
 791             final List<MetadataFacetModel> metadataFacetModelsToAdd =
 792                 new ArrayList<MetadataFacetModel>( properties.size() );
 793
 794             for ( Map.Entry<String, String> entry : properties.entrySet() )
 795             {
 796                 String key = new MetadataFacetModel.KeyBuilder().withKey( entry.getKey() ).withArtifactMetadataModel(
 797                     artifactMetadataModel ).withFacetId( facetId ).withName( metadataFacet.getName() ).build();
 798                 MetadataFacetModel metadataFacetModel =
 799                     new MetadataFacetModel( key, artifactMetadataModel, facetId, entry.getKey(), entry.getValue(),
 800                                             metadataFacet.getName() );
 801                 metadataFacetModelsToAdd.add( metadataFacetModel );
 802             }
 803
 804             getMetadataFacetModelEntityManager().put( metadataFacetModelsToAdd );
 805
 806         }
 807     }
 808
 809     @Override
 810     public void updateProjectVersion( String repositoryId, String namespaceId, String projectId,
 811                                       ProjectVersionMetadata versionMetadata )
 812         throws MetadataRepositoryException
 813     {
 814         String namespaceKey =
 815             new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespaceId ).build();
 816         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 817         if ( namespace == null )
 818         {
 819             namespace = updateOrAddNamespace( repositoryId, namespaceId );
 820         }
 821
 822         String key = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 823
 824         Project project = getProjectEntityManager().get( key );
 825         if ( project == null )
 826         {
 827             project = new Project( key, projectId, namespace );
 828             getProjectEntityManager().put( project );
 829         }
 830
 831         // we don't test of repository and namespace really exist !
 832         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
 833             namespaceId ).withProjectId( projectId ).withId( versionMetadata.getId() ).build();
 834
 835         ProjectVersionMetadataModel projectVersionMetadataModel =
 836             getProjectVersionMetadataModelEntityManager().get( key );
 837
 838         if ( projectVersionMetadataModel == null )
 839         {
 840             projectVersionMetadataModel =
 841                 new BeanReplicator().replicateBean( versionMetadata, ProjectVersionMetadataModel.class );
 842             projectVersionMetadataModel.setRowId( key );
 843         }
 844         projectVersionMetadataModel.setProjectId( projectId );
 845         projectVersionMetadataModel.setNamespace( new Namespace( namespaceId, new Repository( repositoryId ) ) );
 846         projectVersionMetadataModel.setCiManagement( versionMetadata.getCiManagement() );
 847         projectVersionMetadataModel.setIssueManagement( versionMetadata.getIssueManagement() );
 848         projectVersionMetadataModel.setOrganization( versionMetadata.getOrganization() );
 849         projectVersionMetadataModel.setScm( versionMetadata.getScm() );
 850
 851         projectVersionMetadataModel.setMailingLists( versionMetadata.getMailingLists() );
 852         projectVersionMetadataModel.setDependencies( versionMetadata.getDependencies() );
 853         projectVersionMetadataModel.setLicenses( versionMetadata.getLicenses() );
 854
 855         try
 856         {
 857             getProjectVersionMetadataModelEntityManager().put( projectVersionMetadataModel );
 858
 859             ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 860             artifactMetadataModel.setArtifactMetadataModelId(
 861                 new ArtifactMetadataModel.KeyBuilder().withId( versionMetadata.getId() ).withRepositoryId(
 862                     repositoryId ).withNamespace( namespaceId ).withProjectVersion(
 863                     versionMetadata.getVersion() ).withProject( projectId ).build() );
 864             artifactMetadataModel.setRepositoryId( repositoryId );
 865             artifactMetadataModel.setNamespace( namespaceId );
 866             artifactMetadataModel.setProject( projectId );
 867             artifactMetadataModel.setProjectVersion( versionMetadata.getVersion() );
 868             artifactMetadataModel.setVersion( versionMetadata.getVersion() );
 869             // facets etc...
 870             updateFacets( versionMetadata, artifactMetadataModel );
 871         }
 872         catch ( PersistenceException e )
 873         {
 874             throw new MetadataRepositoryException( e.getMessage(), e );
 875         }
 876     }
 877
 878
 879     private static class BooleanHolder
 880     {
 881         private boolean value = false;
 882     }
 883
 884     @Override
 885     public List<String> getMetadataFacets( final String repositoryId, final String facetId )
 886         throws MetadataRepositoryException
 887     {
 888         // FIXME use cql query !!
 889         final List<String> facets = new ArrayList<String>();
 890         this.getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 891         {
 892             @Override
 893             public Boolean apply( MetadataFacetModel metadataFacetModel )
 894             {
 895                 if ( metadataFacetModel != null )
 896                 {
 897                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
 898                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
 899                                                                                    facetId ) )
 900                     {
 901                         facets.add( metadataFacetModel.getName() );
 902                     }
 903                 }
 904                 return Boolean.TRUE;
 905             }
 906         } );
 907
 908         return facets;
 909
 910     }
 911
 912     @Override
 913     public boolean hasMetadataFacet( String repositoryId, String facetId )
 914         throws MetadataRepositoryException
 915     {
 916         return !getMetadataFacets( repositoryId, facetId ).isEmpty();
 917     }
 918
 919     @Override
 920     public MetadataFacet getMetadataFacet( final String repositoryId, final String facetId, final String name )
 921         throws MetadataRepositoryException
 922     {
 923         // FIXME use cql query !!
 924         final List<MetadataFacetModel> facets = new ArrayList<MetadataFacetModel>();
 925         this.getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 926         {
 927             @Override
 928             public Boolean apply( MetadataFacetModel metadataFacetModel )
 929             {
 930                 if ( metadataFacetModel != null )
 931                 {
 932                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
 933                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
 934                                                                                    facetId ) && StringUtils.equals(
 935                         metadataFacetModel.getName(), name ) )
 936                     {
 937                         facets.add( metadataFacetModel );
 938                     }
 939                 }
 940                 return Boolean.TRUE;
 941             }
 942         } );
 943
 944         if ( facets.isEmpty() )
 945         {
 946             return null;
 947         }
 948
 949         MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( facetId );
 950         if ( metadataFacetFactory == null )
 951         {
 952             return null;
 953         }
 954         MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repositoryId, name );
 955         Map<String, String> map = new HashMap<String, String>( facets.size() );
 956         for ( MetadataFacetModel metadataFacetModel : facets )
 957         {
 958             map.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
 959         }
 960         metadataFacet.fromProperties( map );
 961         return metadataFacet;
 962     }
 963
 964     @Override
 965     public void addMetadataFacet( String repositoryId, MetadataFacet metadataFacet )
 966         throws MetadataRepositoryException
 967     {
 968
 969         if ( metadataFacet == null )
 970         {
 971             return;
 972         }
 973
 974         if ( metadataFacet.toProperties().isEmpty() )
 975         {
 976             String key = new MetadataFacetModel.KeyBuilder().withRepositoryId( repositoryId ).withFacetId(
 977                 metadataFacet.getFacetId() ).withName( metadataFacet.getName() ).build();
 978             MetadataFacetModel metadataFacetModel = getMetadataFacetModelEntityManager().get( key );
 979             if ( metadataFacetModel == null )
 980             {
 981                 metadataFacetModel = new MetadataFacetModel();
 982             }
 983             // we need to store the repositoryId
 984             ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 985             artifactMetadataModel.setRepositoryId( repositoryId );
 986             metadataFacetModel.setArtifactMetadataModel( artifactMetadataModel );
 987             metadataFacetModel.setId( key );
 988             metadataFacetModel.setFacetId( metadataFacet.getFacetId() );
 989             metadataFacetModel.setName( metadataFacet.getName() );
 990
 991             try
 992             {
 993                 getMetadataFacetModelEntityManager().put( metadataFacetModel );
 994             }
 995             catch ( PersistenceException e )
 996             {
 997                 throw new MetadataRepositoryException( e.getMessage(), e );
 998             }
 999         }
1000         else
1001         {
1002             for ( Map.Entry<String, String> entry : metadataFacet.toProperties().entrySet() )
1003             {
1004
1005                 String key = new MetadataFacetModel.KeyBuilder().withRepositoryId( repositoryId ).withFacetId(
1006                     metadataFacet.getFacetId() ).withName( metadataFacet.getName() ).withKey( entry.getKey() ).build();
1007
1008                 MetadataFacetModel metadataFacetModel = getMetadataFacetModelEntityManager().get( key );
1009                 if ( metadataFacetModel == null )
1010                 {
1011                     metadataFacetModel = new MetadataFacetModel();
1012                     // we need to store the repositoryId
1013                     ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1014                     artifactMetadataModel.setRepositoryId( repositoryId );
1015                     metadataFacetModel.setArtifactMetadataModel( artifactMetadataModel );
1016                     metadataFacetModel.setId( key );
1017                     metadataFacetModel.setKey( entry.getKey() );
1018                     metadataFacetModel.setFacetId( metadataFacet.getFacetId() );
1019                     metadataFacetModel.setName( metadataFacet.getName() );
1020                 }
1021                 metadataFacetModel.setValue( entry.getValue() );
1022                 try
1023                 {
1024                     getMetadataFacetModelEntityManager().put( metadataFacetModel );
1025                 }
1026                 catch ( PersistenceException e )
1027                 {
1028                     throw new MetadataRepositoryException( e.getMessage(), e );
1029                 }
1030
1031             }
1032         }
1033     }
1034
1035     @Override
1036     public void removeMetadataFacets( final String repositoryId, final String facetId )
1037         throws MetadataRepositoryException
1038     {
1039         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}'", repositoryId, facetId );
1040         final List<MetadataFacetModel> toRemove = new ArrayList<MetadataFacetModel>();
1041
1042         // FIXME cql query
1043         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1044         {
1045             @Override
1046             public Boolean apply( MetadataFacetModel metadataFacetModel )
1047             {
1048                 if ( metadataFacetModel != null )
1049                 {
1050                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
1051                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
1052                                                                                    facetId ) )
1053                     {
1054                         toRemove.add( metadataFacetModel );
1055                     }
1056                 }
1057                 return Boolean.TRUE;
1058             }
1059         } );
1060         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}', toRemove: {}", repositoryId, facetId,
1061                       toRemove );
1062         getMetadataFacetModelEntityManager().remove( toRemove );
1063     }
1064
1065     @Override
1066     public void removeMetadataFacet( final String repositoryId, final String facetId, final String name )
1067         throws MetadataRepositoryException
1068     {
1069         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}'", repositoryId, facetId );
1070         final List<MetadataFacetModel> toRemove = new ArrayList<MetadataFacetModel>();
1071
1072         // FIXME cql query
1073         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1074         {
1075             @Override
1076             public Boolean apply( MetadataFacetModel metadataFacetModel )
1077             {
1078                 if ( metadataFacetModel != null )
1079                 {
1080                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
1081                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
1082                                                                                    facetId ) && StringUtils.equals(
1083                         metadataFacetModel.getName(), name ) )
1084                     {
1085                         toRemove.add( metadataFacetModel );
1086                     }
1087                 }
1088                 return Boolean.TRUE;
1089             }
1090         } );
1091         logger.debug( "removeMetadataFacets repositoryId: '{}', facetId: '{}', toRemove: {}", repositoryId, facetId,
1092                       toRemove );
1093         getMetadataFacetModelEntityManager().remove( toRemove );
1094     }
1095
1096     @Override
1097     public List<ArtifactMetadata> getArtifactsByDateRange( final String repositoryId, final Date startTime,
1098                                                            final Date endTime )
1099         throws MetadataRepositoryException
1100     {
1101
1102         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1103
1104         // FIXME cql query
1105         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1106         {
1107             @Override
1108             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1109             {
1110                 if ( artifactMetadataModel != null )
1111                 {
1112                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
1113                         && artifactMetadataModel.getNamespace() != null &&
1114                         artifactMetadataModel.getProject() != null && artifactMetadataModel.getId() != null )
1115                     {
1116
1117                         Date when = artifactMetadataModel.getWhenGathered();
1118                         if ( ( startTime != null ? when.getTime() >= startTime.getTime() : true ) && ( endTime != null ?
1119                             when.getTime() <= endTime.getTime() : true ) )
1120                         {
1121                             logger.debug( "getArtifactsByDateRange visitAll found: {}", artifactMetadataModel );
1122                             artifactMetadataModels.add( artifactMetadataModel );
1123                         }
1124                     }
1125                 }
1126                 return Boolean.TRUE;
1127             }
1128         } );
1129         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1130
1131         for ( ArtifactMetadataModel model : artifactMetadataModels )
1132         {
1133             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1134             populateFacets( artifactMetadata );
1135             artifactMetadatas.add( artifactMetadata );
1136         }
1137
1138         // FIXME facets ?
1139
1140         logger.debug( "getArtifactsByDateRange repositoryId: {}, startTime: {}, endTime: {}, artifactMetadatas: {}",
1141                       repositoryId, startTime, endTime, artifactMetadatas );
1142
1143         return artifactMetadatas;
1144     }
1145
1146     protected void populateFacets( final ArtifactMetadata artifactMetadata )
1147     {
1148         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1149
1150         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1151         {
1152             @Override
1153             public Boolean apply( MetadataFacetModel metadataFacetModel )
1154             {
1155                 if ( metadataFacetModel != null )
1156                 {
1157                     ArtifactMetadataModel artifactMetadataModel = metadataFacetModel.getArtifactMetadataModel();
1158                     if ( artifactMetadataModel != null )
1159                     {
1160                         if ( StringUtils.equals( artifactMetadata.getRepositoryId(),
1161                                                  artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1162                             artifactMetadata.getNamespace(), artifactMetadataModel.getNamespace() )
1163                             && StringUtils.equals( artifactMetadata.getRepositoryId(),
1164                                                    artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1165                             artifactMetadata.getProject(), artifactMetadataModel.getProject() ) && StringUtils.equals(
1166                             artifactMetadata.getId(), artifactMetadataModel.getId() ) )
1167                         {
1168                             metadataFacetModels.add( metadataFacetModel );
1169                         }
1170                     }
1171                 }
1172                 return Boolean.TRUE;
1173             }
1174         } );
1175         Map<String, Map<String, String>> facetValuesPerFacet = new HashMap<String, Map<String, String>>();
1176
1177         for ( MetadataFacetModel model : metadataFacetModels )
1178         {
1179             Map<String, String> values = facetValuesPerFacet.get( model.getName() );
1180             if ( values == null )
1181             {
1182                 values = new HashMap<String, String>();
1183             }
1184             values.put( model.getKey(), model.getValue() );
1185             facetValuesPerFacet.put( model.getName(), values );
1186         }
1187
1188         for ( Map.Entry<String, Map<String, String>> entry : facetValuesPerFacet.entrySet() )
1189         {
1190             MetadataFacetFactory factory = metadataFacetFactories.get( entry.getKey() );
1191             if ( factory == null )
1192             {
1193                 continue;
1194             }
1195             MetadataFacet metadataFacet =
1196                 factory.createMetadataFacet( artifactMetadata.getRepositoryId(), entry.getKey() );
1197             metadataFacet.fromProperties( entry.getValue() );
1198             artifactMetadata.addFacet( metadataFacet );
1199         }
1200     }
1201
1202     @Override
1203     public List<ArtifactMetadata> getArtifactsByChecksum( final String repositoryId, final String checksum )
1204         throws MetadataRepositoryException
1205     {
1206         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1207
1208         if ( logger.isDebugEnabled() )
1209         {
1210             logger.debug( "all ArtifactMetadataModel: {}", getArtifactMetadataModelEntityManager().getAll() );
1211         }
1212
1213         // FIXME cql query
1214         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1215         {
1216             @Override
1217             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1218             {
1219                 if ( artifactMetadataModel != null )
1220                 {
1221                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
1222                         && artifactMetadataModel.getNamespace() != null &&
1223                         artifactMetadataModel.getProject() != null && artifactMetadataModel.getId() != null )
1224                     {
1225
1226                         if ( StringUtils.equals( checksum, artifactMetadataModel.getMd5() ) || StringUtils.equals(
1227                             checksum, artifactMetadataModel.getSha1() ) )
1228                         {
1229                             artifactMetadataModels.add( artifactMetadataModel );
1230                         }
1231                     }
1232                 }
1233                 return Boolean.TRUE;
1234             }
1235         } );
1236         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1237
1238         for ( ArtifactMetadataModel model : artifactMetadataModels )
1239         {
1240             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1241             populateFacets( artifactMetadata );
1242             artifactMetadatas.add( artifactMetadata );
1243         }
1244
1245         logger.debug( "getArtifactsByChecksum repositoryId: {}, checksum: {}, artifactMetadatas: {}", repositoryId,
1246                       checksum, artifactMetadatas );
1247
1248         return artifactMetadatas;
1249     }
1250
1251     @Override
1252     public void removeArtifact( final String repositoryId, final String namespace, final String project,
1253                                 final String version, final String id )
1254         throws MetadataRepositoryException
1255     {
1256         logger.debug( "removeArtifact repositoryId: '{}', namespace: '{}', project: '{}', version: '{}', id: '{}'",
1257                       repositoryId, namespace, project, version, id );
1258         String key =
1259             new ArtifactMetadataModel.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespace ).withId(
1260                 id ).withProjectVersion( version ).withProject( project ).build();
1261
1262         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1263         artifactMetadataModel.setArtifactMetadataModelId( key );
1264
1265         getArtifactMetadataModelEntityManager().remove( artifactMetadataModel );
1266
1267         key =
1268             new ProjectVersionMetadataModel.KeyBuilder().withId( version ).withRepository( repositoryId ).withNamespace(
1269                 namespace ).withProjectId( project ).build();
1270
1271         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1272         projectVersionMetadataModel.setRowId( key );
1273
1274         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModel );
1275     }
1276
1277     @Override
1278     public void removeArtifact( ArtifactMetadata artifactMetadata, String baseVersion )
1279         throws MetadataRepositoryException
1280     {
1281         logger.debug( "removeArtifact repositoryId: '{}', namespace: '{}', project: '{}', version: '{}', id: '{}'",
1282                       artifactMetadata.getRepositoryId(), artifactMetadata.getNamespace(),
1283                       artifactMetadata.getProject(), baseVersion, artifactMetadata.getId() );
1284         String key =
1285             new ArtifactMetadataModel.KeyBuilder().withRepositoryId( artifactMetadata.getRepositoryId() ).withNamespace(
1286                 artifactMetadata.getNamespace() ).withId( artifactMetadata.getId() ).withProjectVersion(
1287                 baseVersion ).withProject( artifactMetadata.getProject() ).build();
1288
1289         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1290         artifactMetadataModel.setArtifactMetadataModelId( key );
1291
1292         getArtifactMetadataModelEntityManager().remove( artifactMetadataModel );
1293     }
1294
1295     @Override
1296     public void removeArtifact( final String repositoryId, final String namespace, final String project,
1297                                 final String version, final MetadataFacet metadataFacet )
1298         throws MetadataRepositoryException
1299     {
1300         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1301         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1302         {
1303             @Override
1304             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1305             {
1306                 if ( artifactMetadataModel != null )
1307                 {
1308                     if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() )
1309                         && StringUtils.equals( namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals(
1310                         project, artifactMetadataModel.getProject() ) && StringUtils.equals( project,
1311                                                                                              artifactMetadataModel.getVersion() ) )
1312                     {
1313                         artifactMetadataModels.add( artifactMetadataModel );
1314                     }
1315                 }
1316                 return Boolean.TRUE;
1317             }
1318         } );
1319         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
1320
1321     }
1322
1323
1324     @Override
1325     public List<ArtifactMetadata> getArtifacts( final String repositoryId )
1326         throws MetadataRepositoryException
1327     {
1328         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1329         // FIXME use cql query !
1330         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1331         {
1332             @Override
1333             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1334             {
1335                 if ( artifactMetadataModel != null )
1336                 {
1337                     if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() ) )
1338                     {
1339                         artifactMetadataModels.add( artifactMetadataModel );
1340                     }
1341                 }
1342
1343                 return Boolean.TRUE;
1344             }
1345         } );
1346
1347         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1348
1349         for ( ArtifactMetadataModel model : artifactMetadataModels )
1350         {
1351             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1352             populateFacets( artifactMetadata );
1353             artifactMetadatas.add( artifactMetadata );
1354         }
1355
1356         return artifactMetadatas;
1357     }
1358
1359     @Override
1360     public ProjectMetadata getProject( final String repoId, final String namespace, final String id )
1361         throws MetadataResolutionException
1362     {
1363         //basically just checking it exists
1364         // FIXME use cql query
1365
1366         final BooleanHolder booleanHolder = new BooleanHolder();
1367
1368         getProjectEntityManager().visitAll( new Function<Project, Boolean>()
1369         {
1370             @Override
1371             public Boolean apply( Project project )
1372             {
1373                 if ( project != null )
1374                 {
1375                     if ( StringUtils.equals( repoId, project.getNamespace().getRepository().getName() )
1376                         && StringUtils.equals( namespace, project.getNamespace().getName() ) && StringUtils.equals( id,
1377                                                                                                                     project.getProjectId() ) )
1378                     {
1379                         booleanHolder.value = true;
1380                     }
1381                 }
1382                 return Boolean.TRUE;
1383             }
1384         } );
1385
1386         if ( !booleanHolder.value )
1387         {
1388             return null;
1389         }
1390
1391         ProjectMetadata projectMetadata = new ProjectMetadata();
1392         projectMetadata.setId( id );
1393         projectMetadata.setNamespace( namespace );
1394
1395         logger.debug( "getProject repoId: {}, namespace: {}, projectId: {} -> {}", repoId, namespace, id,
1396                       projectMetadata );
1397
1398         return projectMetadata;
1399     }
1400
1401     @Override
1402     public ProjectVersionMetadata getProjectVersion( final String repoId, final String namespace,
1403                                                      final String projectId, final String projectVersion )
1404         throws MetadataResolutionException
1405     {
1406         String key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repoId ).withNamespace(
1407             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
1408
1409         ProjectVersionMetadataModel projectVersionMetadataModel =
1410             getProjectVersionMetadataModelEntityManager().get( key );
1411
1412         if ( projectVersionMetadataModel == null )
1413         {
1414             logger.debug(
1415                 "getProjectVersion repoId: '{}', namespace: '{}', projectId: '{}', projectVersion: {} -> not found",
1416                 repoId, namespace, projectId, projectVersion );
1417             return null;
1418         }
1419
1420         ProjectVersionMetadata projectVersionMetadata =
1421             new BeanReplicator().replicateBean( projectVersionMetadataModel, ProjectVersionMetadata.class );
1422
1423         logger.debug( "getProjectVersion repoId: '{}', namespace: '{}', projectId: '{}', projectVersion: {} -> {}",
1424                       repoId, namespace, projectId, projectVersion, projectVersionMetadata );
1425
1426         projectVersionMetadata.setCiManagement( projectVersionMetadataModel.getCiManagement() );
1427         projectVersionMetadata.setIssueManagement( projectVersionMetadataModel.getIssueManagement() );
1428         projectVersionMetadata.setOrganization( projectVersionMetadataModel.getOrganization() );
1429         projectVersionMetadata.setScm( projectVersionMetadataModel.getScm() );
1430
1431         // FIXME complete collections !!
1432
1433         // facets
1434         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1435         // FIXME use cql query
1436         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1437         {
1438             @Override
1439             public Boolean apply( MetadataFacetModel metadataFacetModel )
1440             {
1441                 if ( metadataFacetModel != null )
1442                 {
1443                     if ( StringUtils.equals( repoId, metadataFacetModel.getArtifactMetadataModel().getRepositoryId() )
1444                         && StringUtils.equals( namespace, metadataFacetModel.getArtifactMetadataModel().getNamespace() )
1445                         && StringUtils.equals( projectId, metadataFacetModel.getArtifactMetadataModel().getProject() )
1446                         && StringUtils.equals( projectVersion,
1447                                                metadataFacetModel.getArtifactMetadataModel().getProjectVersion() ) )
1448                     {
1449                         metadataFacetModels.add( metadataFacetModel );
1450                     }
1451                 }
1452                 return Boolean.TRUE;
1453             }
1454         } );
1455         Map<String, Map<String, String>> metadataFacetsPerFacetIds = new HashMap<String, Map<String, String>>();
1456         for ( MetadataFacetModel metadataFacetModel : metadataFacetModels )
1457         {
1458
1459             Map<String, String> metaValues = metadataFacetsPerFacetIds.get( metadataFacetModel.getFacetId() );
1460             if ( metaValues == null )
1461             {
1462                 metaValues = new HashMap<String, String>();
1463                 metadataFacetsPerFacetIds.put( metadataFacetModel.getFacetId(), metaValues );
1464             }
1465             metaValues.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
1466
1467         }
1468
1469         if ( !metadataFacetsPerFacetIds.isEmpty() )
1470         {
1471             for ( Map.Entry<String, Map<String, String>> entry : metadataFacetsPerFacetIds.entrySet() )
1472             {
1473                 MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( entry.getKey() );
1474                 if ( metadataFacetFactory != null )
1475                 {
1476                     MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repoId, entry.getKey() );
1477                     metadataFacet.fromProperties( entry.getValue() );
1478                     projectVersionMetadata.addFacet( metadataFacet );
1479                 }
1480             }
1481         }
1482
1483         return projectVersionMetadata;
1484     }
1485
1486
1487     @Override
1488     public Collection<ProjectVersionReference> getProjectReferences( String repoId, String namespace, String projectId,
1489                                                                      String projectVersion )
1490         throws MetadataResolutionException
1491     {
1492         // FIXME implement this
1493         return Collections.emptyList();
1494     }
1495
1496     @Override
1497     public Collection<String> getProjects( final String repoId, final String namespace )
1498         throws MetadataResolutionException
1499     {
1500         final Set<String> projects = new HashSet<String>();
1501
1502         // FIXME use cql query
1503         getProjectEntityManager().visitAll( new Function<Project, Boolean>()
1504         {
1505             @Override
1506             public Boolean apply( Project project )
1507             {
1508                 if ( project != null )
1509                 {
1510                     if ( StringUtils.equals( repoId, project.getNamespace().getRepository().getName() )
1511                         && StringUtils.startsWith( project.getNamespace().getName(), namespace ) )
1512                     {
1513                         projects.add( project.getProjectId() );
1514                     }
1515                 }
1516                 return Boolean.TRUE;
1517             }
1518         } );
1519
1520         return projects;
1521     }
1522
1523
1524     @Override
1525     public void removeProjectVersion( final String repoId, final String namespace, final String projectId,
1526                                       final String projectVersion )
1527         throws MetadataRepositoryException
1528     {
1529
1530         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1531
1532         // FIXME use cql query
1533
1534         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1535         {
1536             @Override
1537             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1538             {
1539                 if ( artifactMetadataModel != null )
1540                 {
1541                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1542                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1543                                                                                                  artifactMetadataModel.getProject() )
1544                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1545                     {
1546                         artifactMetadataModels.add( artifactMetadataModel );
1547                     }
1548                 }
1549                 return Boolean.TRUE;
1550             }
1551         } );
1552
1553         logger.debug( "removeProjectVersions:{}", artifactMetadataModels );
1554         if ( artifactMetadataModels.isEmpty() )
1555         {
1556             return;
1557         }
1558
1559         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
1560
1561         String key = new ProjectVersionMetadataModel.KeyBuilder().withProjectId( projectId ).withId(
1562             projectVersion ).withRepository( repoId ).withNamespace( namespace ).build();
1563
1564         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1565         projectVersionMetadataModel.setRowId( key );
1566
1567         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModel );
1568     }
1569
1570     @Override
1571     public Collection<ArtifactMetadata> getArtifacts( final String repoId, final String namespace,
1572                                                       final String projectId, final String projectVersion )
1573         throws MetadataResolutionException
1574     {
1575         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1576         // FIXME use cql query !
1577         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1578         {
1579             @Override
1580             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1581             {
1582                 if ( artifactMetadataModel != null )
1583                 {
1584                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1585                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1586                                                                                                  artifactMetadataModel.getProject() )
1587                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1588                     {
1589                         artifactMetadataModels.add( artifactMetadataModel );
1590                     }
1591                 }
1592
1593                 return Boolean.TRUE;
1594             }
1595         } );
1596
1597         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1598
1599         for ( ArtifactMetadataModel model : artifactMetadataModels )
1600         {
1601             ArtifactMetadata artifactMetadata = new BeanReplicator().replicateBean( model, ArtifactMetadata.class );
1602             populateFacets( artifactMetadata );
1603             artifactMetadatas.add( artifactMetadata );
1604         }
1605
1606         // retrieve facets
1607         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1608         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1609         {
1610             @Override
1611             public Boolean apply( MetadataFacetModel metadataFacetModel )
1612             {
1613                 if ( metadataFacetModel != null )
1614                 {
1615                     if ( StringUtils.equals( repoId, metadataFacetModel.getArtifactMetadataModel().getRepositoryId() )
1616                         && StringUtils.equals( namespace, metadataFacetModel.getArtifactMetadataModel().getNamespace() )
1617                         && StringUtils.equals( projectId, metadataFacetModel.getArtifactMetadataModel().getProject() )
1618                         && StringUtils.equals( projectVersion,
1619                                                metadataFacetModel.getArtifactMetadataModel().getProjectVersion() ) )
1620                     {
1621                         metadataFacetModels.add( metadataFacetModel );
1622                     }
1623
1624                 }
1625                 return Boolean.TRUE;
1626             }
1627         } );
1628
1629         // rebuild MetadataFacet for artifacts
1630
1631         for ( final ArtifactMetadata artifactMetadata : artifactMetadatas )
1632         {
1633             Iterable<MetadataFacetModel> metadataFacetModelIterable =
1634                 Iterables.filter( metadataFacetModels, new Predicate<MetadataFacetModel>()
1635                 {
1636                     @Override
1637                     public boolean apply( MetadataFacetModel metadataFacetModel )
1638                     {
1639                         if ( metadataFacetModel != null )
1640                         {
1641                             return StringUtils.equals( artifactMetadata.getVersion(),
1642                                                        metadataFacetModel.getArtifactMetadataModel().getVersion() );
1643                         }
1644                         return false;
1645                     }
1646                 } );
1647             Iterator<MetadataFacetModel> iterator = metadataFacetModelIterable.iterator();
1648             Map<String, List<MetadataFacetModel>> metadataFacetValuesPerFacetId =
1649                 new HashMap<String, List<MetadataFacetModel>>();
1650             while ( iterator.hasNext() )
1651             {
1652                 MetadataFacetModel metadataFacetModel = iterator.next();
1653                 List<MetadataFacetModel> values = metadataFacetValuesPerFacetId.get( metadataFacetModel.getName() );
1654                 if ( values == null )
1655                 {
1656                     values = new ArrayList<MetadataFacetModel>();
1657                     metadataFacetValuesPerFacetId.put( metadataFacetModel.getFacetId(), values );
1658                 }
1659                 values.add( metadataFacetModel );
1660
1661             }
1662
1663             for ( Map.Entry<String, List<MetadataFacetModel>> entry : metadataFacetValuesPerFacetId.entrySet() )
1664             {
1665                 MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( entry.getKey() );
1666                 if ( metadataFacetFactory != null )
1667                 {
1668                     List<MetadataFacetModel> facetModels = entry.getValue();
1669                     if ( !facetModels.isEmpty() )
1670                     {
1671                         MetadataFacet metadataFacet =
1672                             metadataFacetFactory.createMetadataFacet( repoId, facetModels.get( 0 ).getName() );
1673                         Map<String, String> props = new HashMap<String, String>( facetModels.size() );
1674                         for ( MetadataFacetModel metadataFacetModel : facetModels )
1675                         {
1676                             props.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
1677                         }
1678                         metadataFacet.fromProperties( props );
1679                         artifactMetadata.addFacet( metadataFacet );
1680                     }
1681                 }
1682             }
1683
1684
1685         }
1686
1687         return artifactMetadatas;
1688     }
1689
1690     @Override
1691     public void save()
1692     {
1693         logger.trace( "save" );
1694     }
1695
1696     @Override
1697     public void close()
1698         throws MetadataRepositoryException
1699     {
1700         logger.trace( "close" );
1701     }
1702
1703     @Override
1704     public void revert()
1705     {
1706         logger.warn( "CassandraMetadataRepository cannot revert" );
1707     }
1708
1709     @Override
1710     public boolean canObtainAccess( Class<?> aClass )
1711     {
1712         return false;
1713     }
1714
1715     @Override
1716     public <T> T obtainAccess( Class<T> aClass )
1717         throws MetadataRepositoryException
1718     {
1719         throw new IllegalArgumentException(
1720             "Access using " + aClass + " is not supported on the cassandra metadata storage" );
1721     }
1722 }