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 me.prettyprint.cassandra.model.CqlQuery;
  23 import me.prettyprint.cassandra.model.CqlRows;
  24 import me.prettyprint.cassandra.serializers.LongSerializer;
  25 import me.prettyprint.cassandra.serializers.StringSerializer;
  26 import me.prettyprint.cassandra.service.template.ColumnFamilyTemplate;
  27 import me.prettyprint.cassandra.service.template.ColumnFamilyUpdater;
  28 import me.prettyprint.cassandra.service.template.ThriftColumnFamilyTemplate;
  29 import me.prettyprint.hector.api.Keyspace;
  30 import me.prettyprint.hector.api.beans.ColumnSlice;
  31 import me.prettyprint.hector.api.beans.OrderedRows;
  32 import me.prettyprint.hector.api.beans.Row;
  33 import me.prettyprint.hector.api.exceptions.HInvalidRequestException;
  34 import me.prettyprint.hector.api.factory.HFactory;
  35 import me.prettyprint.hector.api.mutation.MutationResult;
  36 import me.prettyprint.hector.api.query.QueryResult;
  37 import org.apache.archiva.configuration.ArchivaConfiguration;
  38 import org.apache.archiva.metadata.model.ArtifactMetadata;
  39 import org.apache.archiva.metadata.model.FacetedMetadata;
  40 import org.apache.archiva.metadata.model.MetadataFacet;
  41 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  42 import org.apache.archiva.metadata.model.ProjectMetadata;
  43 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  44 import org.apache.archiva.metadata.model.ProjectVersionReference;
  45 import org.apache.archiva.metadata.repository.MetadataRepository;
  46 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  47 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  48 import org.apache.archiva.metadata.repository.cassandra.model.ArtifactMetadataModel;
  49 import org.apache.archiva.metadata.repository.cassandra.model.MetadataFacetModel;
  50 import org.apache.archiva.metadata.repository.cassandra.model.Namespace;
  51 import org.apache.archiva.metadata.repository.cassandra.model.Project;
  52 import org.apache.archiva.metadata.repository.cassandra.model.ProjectVersionMetadataModel;
  53 import org.apache.archiva.metadata.repository.cassandra.model.Repository;
  54 import org.apache.commons.lang.StringUtils;
  55 import org.modelmapper.ModelMapper;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 import javax.persistence.PersistenceException;
  60 import java.util.ArrayList;
  61 import java.util.Collection;
  62 import java.util.Collections;
  63 import java.util.Date;
  64 import java.util.HashMap;
  65 import java.util.HashSet;
  66 import java.util.List;
  67 import java.util.Map;
  68 import java.util.Set;
  69
  70 import static org.apache.archiva.metadata.repository.cassandra.CassandraUtils.column;
  71
  72 /**
  73  * @author Olivier Lamy
  74  * @since 2.0.0
  75  */
  76 public class CassandraMetadataRepository
  77     implements MetadataRepository
  78 {
  79
  80     private Logger logger = LoggerFactory.getLogger( getClass() );
  81
  82     private ArchivaConfiguration configuration;
  83
  84     private final Map<String, MetadataFacetFactory> metadataFacetFactories;
  85
  86     private final CassandraArchivaManager cassandraArchivaManager;
  87
  88     private final ColumnFamilyTemplate<String, String> projectVersionMetadataModelTemplate;
  89
  90     private final ColumnFamilyTemplate<String, String> projectTemplate;
  91
  92     private final ColumnFamilyTemplate<String, String> artifactMetadataTemplate;
  93
  94     private final ColumnFamilyTemplate<String, String> metadataFacetTemplate;
  95
  96     public CassandraMetadataRepository( Map<String, MetadataFacetFactory> metadataFacetFactories,
  97                                         ArchivaConfiguration configuration,
  98                                         CassandraArchivaManager cassandraArchivaManager )
  99     {
 100         this.metadataFacetFactories = metadataFacetFactories;
 101         this.configuration = configuration;
 102         this.cassandraArchivaManager = cassandraArchivaManager;
 103
 104         this.projectVersionMetadataModelTemplate =
 105             new ThriftColumnFamilyTemplate<String, String>( cassandraArchivaManager.getKeyspace(), //
 106                                                             cassandraArchivaManager.getProjectVersionMetadataModelFamilyName(),
 107                                                             StringSerializer.get(), //
 108                                                             StringSerializer.get() );
 109
 110         this.projectTemplate = new ThriftColumnFamilyTemplate<String, String>( cassandraArchivaManager.getKeyspace(), //
 111                                                                                cassandraArchivaManager.getProjectFamilyName(),
 112                                                                                //
 113                                                                                StringSerializer.get(), //
 114                                                                                StringSerializer.get() );
 115
 116         this.artifactMetadataTemplate =
 117             new ThriftColumnFamilyTemplate<String, String>( cassandraArchivaManager.getKeyspace(), //
 118                                                             cassandraArchivaManager.getArtifactMetadataModelFamilyName(),
 119                                                             //
 120                                                             StringSerializer.get(), //
 121                                                             StringSerializer.get() );
 122
 123         this.metadataFacetTemplate =
 124             new ThriftColumnFamilyTemplate<String, String>( cassandraArchivaManager.getKeyspace(), //
 125                                                             cassandraArchivaManager.getMetadataFacetModelFamilyName(),
 126                                                             //
 127                                                             StringSerializer.get(), //
 128                                                             StringSerializer.get() );
 129     }
 130
 131
 132     /**
 133      * if the repository doesn't exist it will be created
 134      *
 135      * @param repositoryId
 136      * @return
 137      */
 138     public Repository getOrCreateRepository( String repositoryId )
 139         throws MetadataRepositoryException
 140     {
 141         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 142         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 143             .createRangeSlicesQuery( keyspace, StringSerializer.get(), StringSerializer.get(),
 144                                      StringSerializer.get() ) //
 145             .setColumnFamily( cassandraArchivaManager.getRepositoryFamilyName() ) //
 146             .setColumnNames( "repositoryName" ) //
 147             .addEqualsExpression( "repositoryName", repositoryId ) //
 148             .execute();
 149
 150         if ( result.get().getCount() < 1 )
 151         {
 152             // we need to create the repository
 153             Repository repository = new Repository( repositoryId );
 154
 155             try
 156             {
 157                 MutationResult mutationResult = HFactory.createMutator( keyspace, StringSerializer.get() ) //
 158                     .addInsertion( repositoryId, //
 159                                    cassandraArchivaManager.getRepositoryFamilyName(), //
 160                                    CassandraUtils.column( "repositoryName", repository.getName() ) ) //
 161                     .execute();
 162                 return repository;
 163             }
 164             catch ( HInvalidRequestException e )
 165             {
 166                 logger.error( e.getMessage(), e );
 167                 throw new MetadataRepositoryException( e.getMessage(), e );
 168             }
 169
 170         }
 171
 172         return new Repository(
 173             result.get().getList().get( 0 ).getColumnSlice().getColumnByName( "repositoryName" ).getValue() );
 174     }
 175
 176
 177     protected Repository getRepository( String repositoryId )
 178         throws MetadataRepositoryException
 179     {
 180         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 181         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 182             .createRangeSlicesQuery( keyspace, StringSerializer.get(), StringSerializer.get(),
 183                                      StringSerializer.get() ) //
 184             .setColumnFamily( cassandraArchivaManager.getRepositoryFamilyName() ) //
 185             .setColumnNames( "repositoryName" ) //
 186             .addEqualsExpression( "repositoryName", repositoryId ) //
 187             .execute();
 188         return ( result.get().getCount() > 0 ) ? new Repository( repositoryId ) : null;
 189     }
 190
 191     @Override
 192     public void updateNamespace( String repositoryId, String namespaceId )
 193         throws MetadataRepositoryException
 194     {
 195         updateOrAddNamespace( repositoryId, namespaceId );
 196     }
 197
 198     public Namespace updateOrAddNamespace( String repositoryId, String namespaceId )
 199         throws MetadataRepositoryException
 200     {
 201         try
 202         {
 203             Repository repository = getOrCreateRepository( repositoryId );
 204
 205             Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 206
 207             String key =
 208                 new Namespace.KeyBuilder().withNamespace( namespaceId ).withRepositoryId( repositoryId ).build();
 209
 210             Namespace namespace = getNamespace( repositoryId, namespaceId );
 211             if ( namespace == null )
 212             {
 213                 namespace = new Namespace( namespaceId, repository );
 214                 HFactory.createMutator( keyspace, StringSerializer.get() )
 215                     //  values
 216                     .addInsertion( key, //
 217                                    cassandraArchivaManager.getNamespaceFamilyName(), //
 218                                    CassandraUtils.column( "name", namespace.getName() ) ) //
 219                     .addInsertion( key, //
 220                                    cassandraArchivaManager.getNamespaceFamilyName(), //
 221                                    CassandraUtils.column( "repositoryName", repository.getName() ) ) //
 222                     .execute();
 223             }
 224
 225             return namespace;
 226         }
 227         catch ( HInvalidRequestException e )
 228         {
 229             logger.error( e.getMessage(), e );
 230             throw new MetadataRepositoryException( e.getMessage(), e );
 231         }
 232     }
 233
 234     protected Namespace getNamespace( String repositoryId, String namespaceId )
 235     {
 236         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 237         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 238             .createRangeSlicesQuery( keyspace, //
 239                                      StringSerializer.get(), //
 240                                      StringSerializer.get(), //
 241                                      StringSerializer.get() ) //
 242             .setColumnFamily( cassandraArchivaManager.getNamespaceFamilyName() ) //
 243             .setColumnNames( "repositoryName", "name" ) //
 244             .addEqualsExpression( "repositoryName", repositoryId ) //
 245             .addEqualsExpression( "name", namespaceId ) //
 246             .execute();
 247         if ( result.get().getCount() > 0 )
 248         {
 249             ColumnSlice<String, String> columnSlice = result.get().getList().get( 0 ).getColumnSlice();
 250             return new Namespace( columnSlice.getColumnByName( "name" ).getValue(), //
 251                                   new Repository( columnSlice.getColumnByName( "repositoryName" ).getValue() ) );
 252
 253         }
 254         return null;
 255     }
 256
 257
 258     @Override
 259     public void removeNamespace( String repositoryId, String namespaceId )
 260         throws MetadataRepositoryException
 261     {
 262         try
 263         {
 264             String key =
 265                 new Namespace.KeyBuilder().withNamespace( namespaceId ).withRepositoryId( repositoryId ).build();
 266
 267             MutationResult result =
 268                 HFactory.createMutator( cassandraArchivaManager.getKeyspace(), new StringSerializer() ) //
 269                     .addDeletion( key, cassandraArchivaManager.getNamespaceFamilyName() ) //
 270                     .execute();
 271
 272
 273         }
 274         catch ( HInvalidRequestException e )
 275         {
 276             logger.error( e.getMessage(), e );
 277             throw new MetadataRepositoryException( e.getMessage(), e );
 278         }
 279     }
 280
 281
 282     @Override
 283     public void removeRepository( final String repositoryId )
 284         throws MetadataRepositoryException
 285     {
 286
 287         // FIXME remove all datas attached to the repositoryId
 288
 289         // retrieve and delete all namespace with this repositoryId
 290
 291         // TODO use cql queries to delete all
 292         List<String> namespacesKey = new ArrayList<String>();
 293
 294         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 295         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 296             .createRangeSlicesQuery( keyspace, //
 297                                      StringSerializer.get(), //
 298                                      StringSerializer.get(), //
 299                                      StringSerializer.get() ) //
 300             .setColumnFamily( cassandraArchivaManager.getNamespaceFamilyName() ) //
 301             .setColumnNames( "repositoryName", "name" ) //
 302             .addEqualsExpression( "repositoryName", repositoryId ) //
 303             .execute();
 304
 305         for ( Row<String, String, String> row : result.get().getList() )
 306         {
 307             namespacesKey.add( row.getKey() );
 308         }
 309
 310         HFactory.createMutator( cassandraArchivaManager.getKeyspace(), new StringSerializer() ) //
 311             .addDeletion( namespacesKey, cassandraArchivaManager.getNamespaceFamilyName() ) //
 312             .execute();
 313
 314         //delete repositoryId
 315         HFactory.createMutator( cassandraArchivaManager.getKeyspace(), new StringSerializer() ) //
 316             .addDeletion( repositoryId, cassandraArchivaManager.getRepositoryFamilyName() ) //
 317             .execute();
 318
 319 /*
 320         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
 321
 322         // remove data related to the repository
 323         this.getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 324         {
 325             @Override
 326             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 327             {
 328                 if ( artifactMetadataModel != null )
 329                 {
 330                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId ) )
 331                     {
 332                         artifactMetadataModels.add( artifactMetadataModel );
 333                     }
 334                 }
 335                 return Boolean.TRUE;
 336             }
 337         } );
 338
 339         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
 340
 341         final List<Namespace> namespaces = new ArrayList<Namespace>();
 342
 343         getNamespaceEntityManager().visitAll( new Function<Namespace, Boolean>()
 344         {
 345             @Override
 346             public Boolean apply( Namespace namespace )
 347             {
 348                 if ( namespace != null )
 349                 {
 350                     if ( StringUtils.equals( namespace.getRepository().getId(), repositoryId ) )
 351                     {
 352                         namespaces.add( namespace );
 353                     }
 354                 }
 355                 return Boolean.TRUE;
 356             }
 357         } );
 358
 359         getNamespaceEntityManager().remove( namespaces );
 360
 361         final List<Project> projects = new ArrayList<Project>();
 362         getProjectEntityManager().visitAll( new Function<Project, Boolean>()
 363         {
 364             @Override
 365             public Boolean apply( Project project )
 366             {
 367                 if ( project != null )
 368                 {
 369                     if ( StringUtils.equals( project.getNamespace().getRepository().getId(), repositoryId ) )
 370                     {
 371                         projects.add( project );
 372                     }
 373                 }
 374                 return Boolean.TRUE;
 375             }
 376         } );
 377
 378         getProjectEntityManager().remove( projects );
 379
 380         // TODO  cleanup or not
 381         //final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>(  );
 382         //getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
 383
 384         final List<ProjectVersionMetadataModel> projectVersionMetadataModels =
 385             new ArrayList<ProjectVersionMetadataModel>();
 386
 387         getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 388         {
 389             @Override
 390             public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 391             {
 392                 if ( projectVersionMetadataModel != null )
 393                 {
 394                     if ( StringUtils.equals( projectVersionMetadataModel.getNamespace().getRepository().getId(),
 395                                              repositoryId ) )
 396                     {
 397                         projectVersionMetadataModels.add( projectVersionMetadataModel );
 398                     }
 399                 }
 400                 return Boolean.TRUE;
 401             }
 402         } );
 403
 404         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModels );
 405
 406         Repository repository = getRepositoryEntityManager().get( repositoryId );
 407         if ( repository != null )
 408         {
 409             getRepositoryEntityManager().remove( repository );
 410         }
 411
 412     */
 413     }
 414
 415     @Override
 416     public Collection<String> getRepositories()
 417         throws MetadataRepositoryException
 418     {
 419         try
 420         {
 421             logger.debug( "getRepositories" );
 422
 423             final QueryResult<OrderedRows<String, String, String>> cResult = //
 424                 HFactory.createRangeSlicesQuery( cassandraArchivaManager.getKeyspace(), //
 425                                                  StringSerializer.get(), //
 426                                                  StringSerializer.get(), //
 427                                                  StringSerializer.get() ) //
 428                     .setColumnFamily( cassandraArchivaManager.getRepositoryFamilyName() ) //
 429                     .setColumnNames( "repositoryName" ) //
 430                     .setRange( null, null, false, Integer.MAX_VALUE ) //
 431                     .execute();
 432
 433             List<String> repoIds = new ArrayList<String>( cResult.get().getCount() );
 434
 435             for ( Row<String, String, String> row : cResult.get() )
 436             {
 437                 repoIds.add( row.getColumnSlice().getColumnByName( "repositoryName" ).getValue() );
 438             }
 439
 440             return repoIds;
 441         }
 442         catch ( PersistenceException e )
 443         {
 444             throw new MetadataRepositoryException( e.getMessage(), e );
 445         }
 446
 447     }
 448
 449
 450     @Override
 451     public Collection<String> getRootNamespaces( final String repoId )
 452         throws MetadataResolutionException
 453     {
 454         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 455         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 456             .createRangeSlicesQuery( keyspace, //
 457                                      StringSerializer.get(), //
 458                                      StringSerializer.get(), //
 459                                      StringSerializer.get() ) //
 460             .setColumnFamily( cassandraArchivaManager.getNamespaceFamilyName() ) //
 461             .setColumnNames( "name" ) //
 462             .addEqualsExpression( "repositoryName", repoId ) //
 463             .execute();
 464
 465         Set<String> namespaces = new HashSet<String>( result.get().getCount() );
 466
 467         for ( Row<String, String, String> row : result.get() )
 468         {
 469             namespaces.add(
 470                 StringUtils.substringBefore( row.getColumnSlice().getColumnByName( "name" ).getValue(), "." ) );
 471         }
 472
 473         return namespaces;
 474     }
 475
 476
 477     @Override
 478     public Collection<String> getNamespaces( final String repoId, final String namespaceId )
 479         throws MetadataResolutionException
 480     {
 481         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 482         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 483             .createRangeSlicesQuery( keyspace, //
 484                                      StringSerializer.get(), //
 485                                      StringSerializer.get(), //
 486                                      StringSerializer.get() ) //
 487             .setColumnFamily( cassandraArchivaManager.getNamespaceFamilyName() ) //
 488             .setColumnNames( "name" ) //
 489             .addEqualsExpression( "repositoryName", repoId ) //
 490             .execute();
 491
 492         List<String> namespaces = new ArrayList<String>( result.get().getCount() );
 493
 494         for ( Row<String, String, String> row : result.get() )
 495         {
 496             String currentNamespace = row.getColumnSlice().getColumnByName( "name" ).getValue();
 497             if ( StringUtils.startsWith( currentNamespace, namespaceId ) && ( StringUtils.length( currentNamespace )
 498                 > StringUtils.length( namespaceId ) ) )
 499             {
 500                 // store after namespaceId '.' but before next '.'
 501                 // call org namespace org.apache.maven.shared -> stored apache
 502
 503                 String calledNamespace = StringUtils.endsWith( namespaceId, "." ) ? namespaceId : namespaceId + ".";
 504                 String storedNamespace = StringUtils.substringAfter( currentNamespace, calledNamespace );
 505
 506                 storedNamespace = StringUtils.substringBefore( storedNamespace, "." );
 507
 508                 namespaces.add( storedNamespace );
 509             }
 510         }
 511
 512         return namespaces;
 513
 514     }
 515
 516
 517     public List<String> getNamespaces( final String repoId )
 518         throws MetadataResolutionException
 519     {
 520         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 521         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 522             .createRangeSlicesQuery( keyspace, //
 523                                      StringSerializer.get(), //
 524                                      StringSerializer.get(), //
 525                                      StringSerializer.get() ) //
 526             .setColumnFamily( cassandraArchivaManager.getNamespaceFamilyName() ) //
 527             .setColumnNames( "name" ) //
 528             .addEqualsExpression( "repositoryName", repoId ) //
 529             .execute();
 530
 531         List<String> namespaces = new ArrayList<String>( result.get().getCount() );
 532
 533         for ( Row<String, String, String> row : result.get() )
 534         {
 535             namespaces.add( row.getColumnSlice().getColumnByName( "name" ).getValue() );
 536         }
 537
 538         return namespaces;
 539     }
 540
 541
 542     @Override
 543     public void updateProject( String repositoryId, ProjectMetadata projectMetadata )
 544         throws MetadataRepositoryException
 545     {
 546         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 547
 548         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 549             .createRangeSlicesQuery( keyspace, //
 550                                      StringSerializer.get(), //
 551                                      StringSerializer.get(), //
 552                                      StringSerializer.get() ) //
 553             .setColumnFamily( cassandraArchivaManager.getProjectFamilyName() ) //
 554             .setColumnNames( "projectId" ) //
 555             .addEqualsExpression( "repositoryName", repositoryId ) //
 556             .addEqualsExpression( "namespaceId", projectMetadata.getNamespace() ) //
 557             .addEqualsExpression( "projectId", projectMetadata.getId() ) //
 558             .execute();
 559
 560
 561
 562         // project exists ? if yes return nothing to update here
 563         if ( result.get().getCount() > 0 )
 564         {
 565             return;
 566         }
 567         else
 568         {
 569             Namespace namespace = updateOrAddNamespace( repositoryId, projectMetadata.getNamespace() );
 570
 571             String key =
 572                 new Project.KeyBuilder().withProjectId( projectMetadata.getId() ).withNamespace( namespace ).build();
 573
 574             projectTemplate.createMutator()
 575                 //  values
 576                 .addInsertion( key, //
 577                                cassandraArchivaManager.getProjectFamilyName(), //
 578                                CassandraUtils.column( "projectId", projectMetadata.getId() ) ) //
 579                 .addInsertion( key, //
 580                                cassandraArchivaManager.getProjectFamilyName(), //
 581                                CassandraUtils.column( "repositoryName", repositoryId ) ) //
 582                 .addInsertion( key, //
 583                                cassandraArchivaManager.getProjectFamilyName(), //
 584                                CassandraUtils.column( "namespaceId", projectMetadata.getNamespace() ) )//
 585                 .execute();
 586         }
 587     }
 588
 589     @Override
 590     public Collection<String> getProjects( final String repoId, final String namespace )
 591         throws MetadataResolutionException
 592     {
 593
 594         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 595
 596         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 597             .createRangeSlicesQuery( keyspace, //
 598                                      StringSerializer.get(), //
 599                                      StringSerializer.get(), //
 600                                      StringSerializer.get() ) //
 601             .setColumnFamily( cassandraArchivaManager.getProjectFamilyName() ) //
 602             .setColumnNames( "projectId" ) //
 603             .addEqualsExpression( "repositoryName", repoId ) //
 604             .addEqualsExpression( "namespaceId", namespace ) //
 605             .execute();
 606
 607         final Set<String> projects = new HashSet<String>( result.get().getCount() );
 608
 609         for ( Row<String, String, String> row : result.get() )
 610         {
 611             projects.add( row.getColumnSlice().getColumnByName( "projectId" ).getValue() );
 612         }
 613
 614         return projects;
 615     }
 616
 617     @Override
 618     public void removeProject( final String repositoryId, final String namespaceId, final String projectId )
 619         throws MetadataRepositoryException
 620     {
 621
 622         String key = new Project.KeyBuilder() //
 623             .withProjectId( projectId ) //
 624             .withNamespace( new Namespace( namespaceId, new Repository( repositoryId ) ) ) //
 625             .build();
 626
 627         HFactory.createMutator( cassandraArchivaManager.getKeyspace(), new StringSerializer() ) //
 628             .addDeletion( key, cassandraArchivaManager.getProjectFamilyName() ) //
 629             .execute();
 630
 631         // TODO finish linked data to delete
 632
 633 /*        // cleanup ArtifactMetadataModel
 634         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
 635
 636         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
 637         {
 638             @Override
 639             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
 640             {
 641                 if ( artifactMetadataModel != null )
 642                 {
 643                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
 644                         && StringUtils.equals( artifactMetadataModel.getNamespace(), namespaceId )
 645                         && StringUtils.equals( artifactMetadataModel.getProject(), projectId ) )
 646                     {
 647                         artifactMetadataModels.add( artifactMetadataModel );
 648                     }
 649                 }
 650                 return Boolean.TRUE;
 651             }
 652         } );
 653
 654         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
 655
 656         Namespace namespace = new Namespace( namespaceId, new Repository( repositoryId ) );
 657
 658         final List<ProjectVersionMetadataModel> projectVersionMetadataModels =
 659             new ArrayList<ProjectVersionMetadataModel>();
 660
 661         getProjectVersionMetadataModelEntityManager().visitAll( new Function<ProjectVersionMetadataModel, Boolean>()
 662         {
 663             @Override
 664             public Boolean apply( ProjectVersionMetadataModel projectVersionMetadataModel )
 665             {
 666                 if ( projectVersionMetadataModel != null )
 667                 {
 668                     if ( StringUtils.equals( repositoryId,
 669                                              projectVersionMetadataModel.getNamespace().getRepository().getName() )
 670                         && StringUtils.equals( namespaceId, projectVersionMetadataModel.getNamespace().getName() )
 671                         && StringUtils.equals( projectId, projectVersionMetadataModel.getProjectId() ) )
 672                     {
 673                         projectVersionMetadataModels.add( projectVersionMetadataModel );
 674                     }
 675                 }
 676                 return Boolean.TRUE;
 677             }
 678         } );
 679
 680         if ( !projectVersionMetadataModels.isEmpty() )
 681         {
 682             getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModels );
 683         }
 684
 685         String key = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 686
 687         Project project = getProjectEntityManager().get( key );
 688         if ( project == null )
 689         {
 690             logger.debug( "removeProject notfound" );
 691             return;
 692         }
 693         logger.debug( "removeProject {}", project );
 694
 695         getProjectEntityManager().remove( project );*/
 696     }
 697
 698     @Override
 699     public Collection<String> getProjectVersions( final String repoId, final String namespace, final String projectId )
 700         throws MetadataResolutionException
 701     {
 702
 703         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 704
 705         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 706             .createRangeSlicesQuery( keyspace, //
 707                                      StringSerializer.get(), //
 708                                      StringSerializer.get(), //
 709                                      StringSerializer.get() ) //
 710             .setColumnFamily( cassandraArchivaManager.getProjectVersionMetadataModelFamilyName() ) //
 711             .setColumnNames( "id" ) //
 712             .addEqualsExpression( "repositoryName", repoId ) //
 713             .addEqualsExpression( "namespaceId", namespace ) //
 714             .addEqualsExpression( "projectId", projectId ) //
 715             .execute();
 716
 717         int count = result.get().getCount();
 718
 719         if ( count < 1 )
 720         {
 721             return Collections.emptyList();
 722         }
 723
 724         Set<String> versions = new HashSet<String>( count );
 725
 726         for ( Row<String, String, String> orderedRows : result.get() )
 727         {
 728             versions.add( orderedRows.getColumnSlice().getColumnByName( "id" ).getValue() );
 729         }
 730
 731         return versions;
 732
 733     }
 734
 735     @Override
 736     public ProjectMetadata getProject( final String repoId, final String namespace, final String id )
 737         throws MetadataResolutionException
 738     {
 739
 740         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 741
 742         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 743             .createRangeSlicesQuery( keyspace, //
 744                                      StringSerializer.get(), //
 745                                      StringSerializer.get(), //
 746                                      StringSerializer.get() ) //
 747             .setColumnFamily( cassandraArchivaManager.getProjectFamilyName() ) //
 748             .setColumnNames( "projectId" ) //
 749             .addEqualsExpression( "repositoryName", repoId ) //
 750             .addEqualsExpression( "namespaceId", namespace ) //
 751             .addEqualsExpression( "projectId", id ) //
 752             .execute();
 753
 754         int count = result.get().getCount();
 755
 756         if ( count < 1 )
 757         {
 758             return null;
 759         }
 760
 761         ProjectMetadata projectMetadata = new ProjectMetadata();
 762         projectMetadata.setId( id );
 763         projectMetadata.setNamespace( namespace );
 764
 765         logger.debug( "getProject repoId: {}, namespace: {}, projectId: {} -> {}", repoId, namespace, id,
 766                       projectMetadata );
 767
 768         return projectMetadata;
 769     }
 770
 771     protected ProjectVersionMetadataModel map( ColumnSlice<String, String> columnSlice )
 772     {
 773         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
 774         projectVersionMetadataModel.setId( columnSlice.getColumnByName( "id" ).getValue() );
 775         projectVersionMetadataModel.setDescription( columnSlice.getColumnByName( "description" ).getValue() );
 776         projectVersionMetadataModel.setName( columnSlice.getColumnByName( "name" ).getValue() );
 777         projectVersionMetadataModel.setNamespace(
 778             new Namespace( columnSlice.getColumnByName( "namespaceId" ).getValue(), //
 779                            new Repository( columnSlice.getColumnByName( "repositoryName" ).getValue() ) )
 780         );
 781         projectVersionMetadataModel.setIncomplete(
 782             Boolean.parseBoolean( columnSlice.getColumnByName( "incomplete" ).getValue() ) );
 783         projectVersionMetadataModel.setProjectId( columnSlice.getColumnByName( "projectId" ).getValue() );
 784         projectVersionMetadataModel.setUrl( columnSlice.getColumnByName( "url" ).getValue() );
 785         return projectVersionMetadataModel;
 786     }
 787
 788     @Override
 789     public void updateProjectVersion( String repositoryId, String namespaceId, String projectId,
 790                                       ProjectVersionMetadata versionMetadata )
 791         throws MetadataRepositoryException
 792     {
 793         try
 794         {
 795             Namespace namespace = getNamespace( repositoryId, namespaceId );
 796
 797             if ( namespace == null )
 798             {
 799                 namespace = updateOrAddNamespace( repositoryId, namespaceId );
 800             }
 801
 802             if ( getProject( repositoryId, namespaceId, projectId ) == null )
 803             {
 804                 ProjectMetadata projectMetadata = new ProjectMetadata();
 805                 projectMetadata.setNamespace( namespaceId );
 806                 projectMetadata.setId( projectId );
 807                 updateProject( repositoryId, projectMetadata );
 808             }
 809
 810         }
 811         catch ( MetadataResolutionException e )
 812         {
 813             throw new MetadataRepositoryException( e.getMessage(), e );
 814         }
 815
 816         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
 817         QueryResult<OrderedRows<String, String, String>> result = HFactory //
 818             .createRangeSlicesQuery( keyspace, //
 819                                      StringSerializer.get(), //
 820                                      StringSerializer.get(), //
 821                                      StringSerializer.get() ) //
 822             .setColumnFamily( cassandraArchivaManager.getProjectVersionMetadataModelFamilyName() ) //
 823             .setColumnNames( "id" ) //
 824             .addEqualsExpression( "repositoryName", repositoryId ) //
 825             .addEqualsExpression( "namespaceId", namespaceId ) //
 826             .addEqualsExpression( "projectId", projectId ) //
 827             .addEqualsExpression( "id", versionMetadata.getId() ).execute();
 828
 829         ProjectVersionMetadataModel projectVersionMetadataModel = null;
 830         boolean creation = true;
 831         if ( result.get().getCount() > 0 )
 832         {
 833             projectVersionMetadataModel = map( result.get().getList().get( 0 ).getColumnSlice() );
 834             creation = false;
 835         }
 836         else
 837         {
 838             projectVersionMetadataModel = getModelMapper().map( versionMetadata, ProjectVersionMetadataModel.class );
 839         }
 840
 841         projectVersionMetadataModel.setProjectId( projectId );
 842         projectVersionMetadataModel.setNamespace( new Namespace( namespaceId, new Repository( repositoryId ) ) );
 843         projectVersionMetadataModel.setCiManagement( versionMetadata.getCiManagement() );
 844         projectVersionMetadataModel.setIssueManagement( versionMetadata.getIssueManagement() );
 845         projectVersionMetadataModel.setOrganization( versionMetadata.getOrganization() );
 846         projectVersionMetadataModel.setScm( versionMetadata.getScm() );
 847
 848         projectVersionMetadataModel.setMailingLists( versionMetadata.getMailingLists() );
 849         projectVersionMetadataModel.setDependencies( versionMetadata.getDependencies() );
 850         projectVersionMetadataModel.setLicenses( versionMetadata.getLicenses() );
 851
 852         // we don't test of repository and namespace really exist !
 853         String key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
 854             namespaceId ).withProjectId( projectId ).withId( versionMetadata.getId() ).build();
 855
 856         // FIXME nested objects to store!!!
 857         if ( creation )
 858         {
 859             String cf = cassandraArchivaManager.getProjectFamilyName();
 860             projectVersionMetadataModelTemplate.createMutator()
 861                 //  values
 862                 .addInsertion( key, //
 863                                cf, //
 864                                CassandraUtils.column( "projectId", projectId ) ) //
 865                 .addInsertion( key, //
 866                                cf, //
 867                                CassandraUtils.column( "repositoryName", repositoryId ) ) //
 868                 .addInsertion( key, //
 869                                cf, //
 870                                CassandraUtils.column( "namespaceId", namespaceId ) )//
 871                 .addInsertion( key, //
 872                                cf, //
 873                                CassandraUtils.column( "id", versionMetadata.getVersion() ) ) //
 874                 .addInsertion( key, //
 875                                cf, //
 876                                CassandraUtils.column( "description", versionMetadata.getDescription() ) ) //
 877                 .addInsertion( key, //
 878                                cf, //
 879                                CassandraUtils.column( "name", versionMetadata.getName() ) ) //
 880                 .addInsertion( key, //
 881                                cf, //
 882                                CassandraUtils.column( "incomplete", Boolean.toString( versionMetadata.isIncomplete() ) )
 883                 ) //
 884                 .addInsertion( key, //
 885                                cf, //
 886                                CassandraUtils.column( "url", versionMetadata.getUrl() ) ) //
 887                 .execute();
 888         }
 889         else
 890         {
 891             ColumnFamilyUpdater<String, String> updater = projectVersionMetadataModelTemplate.createUpdater( key );
 892             updater.setString( "projectId", projectId );
 893             updater.setString( "repositoryName", repositoryId );
 894             updater.setString( "namespaceId", namespaceId );
 895             updater.setString( "id", versionMetadata.getVersion() );
 896             updater.setString( "description", versionMetadata.getDescription() );
 897             updater.setString( "name", versionMetadata.getName() );
 898             updater.setString( "incomplete", Boolean.toString( versionMetadata.isIncomplete() ) );
 899             updater.setString( "url", versionMetadata.getUrl() );
 900
 901             projectVersionMetadataModelTemplate.update( updater );
 902
 903         }
 904
 905         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 906         // FIXME
 907         /*artifactMetadataModel.setArtifactMetadataModelId(
 908             new ArtifactMetadataModel.KeyBuilder().withId( versionMetadata.getId() ).withRepositoryId(
 909                 repositoryId ).withNamespace( namespaceId ).withProjectVersion(
 910                 versionMetadata.getVersion() ).withProject( projectId ).build()
 911         );*/
 912         artifactMetadataModel.setRepositoryId( repositoryId );
 913         artifactMetadataModel.setNamespace( namespaceId );
 914         artifactMetadataModel.setProject( projectId );
 915         artifactMetadataModel.setProjectVersion( versionMetadata.getVersion() );
 916         artifactMetadataModel.setVersion( versionMetadata.getVersion() );
 917         updateFacets( versionMetadata, artifactMetadataModel );
 918
 919 /*        String namespaceKey =
 920             new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespaceId ).build();
 921         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
 922         if ( namespace == null )
 923         {
 924             namespace = updateOrAddNamespace( repositoryId, namespaceId );
 925         }
 926
 927         String key = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
 928
 929         Project project = getProjectEntityManager().get( key );
 930         if ( project == null )
 931         {
 932             project = new Project( key, projectId, namespace );
 933             getProjectEntityManager().put( project );
 934         }
 935
 936         // we don't test of repository and namespace really exist !
 937         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
 938             namespaceId ).withProjectId( projectId ).withId( versionMetadata.getId() ).build();
 939
 940         ProjectVersionMetadataModel projectVersionMetadataModel =
 941             getProjectVersionMetadataModelEntityManager().get( key );
 942
 943         if ( projectVersionMetadataModel == null )
 944         {
 945             projectVersionMetadataModel = getModelMapper().map( versionMetadata, ProjectVersionMetadataModel.class );
 946             projectVersionMetadataModel.setRowId( key );
 947         }
 948         projectVersionMetadataModel.setProjectId( projectId );
 949         projectVersionMetadataModel.setNamespace( new Namespace( namespaceId, new Repository( repositoryId ) ) );
 950         projectVersionMetadataModel.setCiManagement( versionMetadata.getCiManagement() );
 951         projectVersionMetadataModel.setIssueManagement( versionMetadata.getIssueManagement() );
 952         projectVersionMetadataModel.setOrganization( versionMetadata.getOrganization() );
 953         projectVersionMetadataModel.setScm( versionMetadata.getScm() );
 954
 955         projectVersionMetadataModel.setMailingLists( versionMetadata.getMailingLists() );
 956         projectVersionMetadataModel.setDependencies( versionMetadata.getDependencies() );
 957         projectVersionMetadataModel.setLicenses( versionMetadata.getLicenses() );
 958
 959         try
 960         {
 961             getProjectVersionMetadataModelEntityManager().put( projectVersionMetadataModel );
 962
 963             ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
 964             artifactMetadataModel.setArtifactMetadataModelId(
 965                 new ArtifactMetadataModel.KeyBuilder().withId( versionMetadata.getId() ).withRepositoryId(
 966                     repositoryId ).withNamespace( namespaceId ).withProjectVersion(
 967                     versionMetadata.getVersion() ).withProject( projectId ).build()
 968             );
 969             artifactMetadataModel.setRepositoryId( repositoryId );
 970             artifactMetadataModel.setNamespace( namespaceId );
 971             artifactMetadataModel.setProject( projectId );
 972             artifactMetadataModel.setProjectVersion( versionMetadata.getVersion() );
 973             artifactMetadataModel.setVersion( versionMetadata.getVersion() );
 974             // facets etc...
 975             updateFacets( versionMetadata, artifactMetadataModel );
 976         }
 977         catch ( PersistenceException e )
 978         {
 979             throw new MetadataRepositoryException( e.getMessage(), e );
 980         }*/
 981     }
 982
 983
 984     @Override
 985     public void updateArtifact( String repositoryId, String namespaceId, String projectId, String projectVersion,
 986                                 ArtifactMetadata artifactMeta )
 987         throws MetadataRepositoryException
 988     {
 989
 990         Namespace namespace = getNamespace( repositoryId, namespaceId );
 991         if ( namespace == null )
 992         {
 993             namespace = updateOrAddNamespace( repositoryId, namespaceId );
 994         }
 995
 996         ProjectMetadata projectMetadata = new ProjectMetadata();
 997         projectMetadata.setId( projectId );
 998         projectMetadata.setNamespace( namespaceId );
 999         updateProject( repositoryId, projectMetadata );
1000
1001         String key = new ArtifactMetadataModel.KeyBuilder().withNamespace( namespace ).withProject( projectId ).withId(
1002             artifactMeta.getId() ).withProjectVersion( projectVersion ).build();
1003
1004         // exists?
1005
1006         boolean exists = this.artifactMetadataTemplate.isColumnsExist( key );
1007
1008         if ( exists )
1009         {
1010             // updater
1011             ColumnFamilyUpdater<String, String> updater = this.artifactMetadataTemplate.createUpdater( key );
1012             updater.setLong( "fileLastModified", artifactMeta.getFileLastModified().getTime() );
1013             updater.setLong( "whenGathered", artifactMeta.getWhenGathered().getTime() );
1014             updater.setLong( "size", artifactMeta.getSize() );
1015             updater.setString( "md5", artifactMeta.getMd5() );
1016             updater.setString( "sha1", artifactMeta.getSha1() );
1017             updater.setString( "version", artifactMeta.getVersion() );
1018             this.artifactMetadataTemplate.update( updater );
1019         }
1020         else
1021         {
1022             String cf = this.cassandraArchivaManager.getArtifactMetadataModelFamilyName();
1023             // create
1024             this.artifactMetadataTemplate.createMutator().addInsertion( key, //
1025                                                                         cf, //
1026                                                                         column( "id", artifactMeta.getId() ) )//
1027                 .addInsertion( key, //
1028                                cf, //
1029                                column( "repositoryName", repositoryId ) ) //
1030                 .addInsertion( key, //
1031                                cf, //
1032                                column( "namespaceId", namespaceId ) ).addInsertion( key, //
1033                                                                                     cf, //
1034                                                                                     column( "project",
1035                                                                                             artifactMeta.getProject() )
1036             ) //
1037                 .addInsertion( key, //
1038                                cf, //
1039                                column( "projectVersion", artifactMeta.getProjectVersion() ) ) //
1040                 .addInsertion( key, //
1041                                cf, //
1042                                column( "version", artifactMeta.getVersion() ) ) //
1043                 .addInsertion( key, //
1044                                cf, //
1045                                column( "fileLastModified", artifactMeta.getFileLastModified().getTime() ) ) //
1046                 .addInsertion( key, //
1047                                cf, //
1048                                column( "size", artifactMeta.getSize() ) ) //
1049                 .addInsertion( key, //
1050                                cf, //
1051                                column( "md5", artifactMeta.getMd5() ) ) //
1052                 .addInsertion( key, //
1053                                cf, //
1054                                column( "sha1", artifactMeta.getSha1() ) ) //
1055                 .addInsertion( key, //
1056                                cf, //
1057                                column( "whenGathered", artifactMeta.getWhenGathered().getTime() ) )//
1058                 .execute();
1059         }
1060
1061         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
1062             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
1063
1064         exists = this.projectVersionMetadataModelTemplate.isColumnsExist( key );
1065
1066         if ( !exists )
1067         {
1068             ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1069             projectVersionMetadataModel.setProjectId( projectId );
1070             projectVersionMetadataModel.setId( projectVersion );
1071             projectVersionMetadataModel.setNamespace( namespace );
1072
1073             String cf = this.cassandraArchivaManager.getProjectVersionMetadataModelFamilyName();
1074
1075             projectVersionMetadataModelTemplate.createMutator() //
1076                 .addInsertion( key, cf, column( "namespaceId", namespace.getName() ) ) //
1077                 .addInsertion( key, cf, column( "repositoryName", repositoryId ) ) //
1078                 .addInsertion( key, cf, column( "id", artifactMeta.getId() ) ) //
1079                 .addInsertion( key, cf, column( "projectId", projectId ) ) //
1080                 .execute();
1081
1082         }
1083
1084         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1085         // FIXME
1086         /*artifactMetadataModel.setArtifactMetadataModelId(
1087             new ArtifactMetadataModel.KeyBuilder().withId( versionMetadata.getId() ).withRepositoryId(
1088                 repositoryId ).withNamespace( namespaceId ).withProjectVersion(
1089                 versionMetadata.getVersion() ).withProject( projectId ).build()
1090         );*/
1091         artifactMetadataModel.setRepositoryId( repositoryId );
1092         artifactMetadataModel.setNamespace( namespaceId );
1093         artifactMetadataModel.setProject( projectId );
1094         artifactMetadataModel.setProjectVersion( artifactMeta.getVersion() );
1095         artifactMetadataModel.setVersion( artifactMeta.getVersion() );
1096         // now facets
1097         updateFacets( artifactMeta, artifactMetadataModel );
1098
1099
1100 /*        String namespaceKey =
1101             new Namespace.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespaceId ).build();
1102         // create the namespace if not exists
1103         Namespace namespace = getNamespaceEntityManager().get( namespaceKey );
1104         if ( namespace == null )
1105         {
1106             namespace = updateOrAddNamespace( repositoryId, namespaceId );
1107         }
1108
1109         // create the project if not exist
1110         String projectKey = new Project.KeyBuilder().withNamespace( namespace ).withProjectId( projectId ).build();
1111
1112         Project project = getProjectEntityManager().get( projectKey );
1113         if ( project == null )
1114         {
1115             project = new Project( projectKey, projectId, namespace );
1116             try
1117             {
1118                 getProjectEntityManager().put( project );
1119             }
1120             catch ( PersistenceException e )
1121             {
1122                 throw new MetadataRepositoryException( e.getMessage(), e );
1123             }
1124         }
1125
1126         String key = new ArtifactMetadataModel.KeyBuilder().withNamespace( namespace ).withProject( projectId ).withId(
1127             artifactMeta.getId() ).withProjectVersion( projectVersion ).build();
1128
1129         ArtifactMetadataModel artifactMetadataModel = getArtifactMetadataModelEntityManager().get( key );
1130         if ( artifactMetadataModel == null )
1131         {
1132             artifactMetadataModel = new ArtifactMetadataModel( key, artifactMeta.getId(), repositoryId, namespaceId,
1133                                                                artifactMeta.getProject(), projectVersion,
1134                                                                artifactMeta.getVersion(),
1135                                                                artifactMeta.getFileLastModified(),
1136                                                                artifactMeta.getSize(), artifactMeta.getMd5(),
1137                                                                artifactMeta.getSha1(), artifactMeta.getWhenGathered() );
1138
1139         }
1140         else
1141         {
1142             artifactMetadataModel.setFileLastModified( artifactMeta.getFileLastModified().getTime() );
1143             artifactMetadataModel.setWhenGathered( artifactMeta.getWhenGathered().getTime() );
1144             artifactMetadataModel.setSize( artifactMeta.getSize() );
1145             artifactMetadataModel.setMd5( artifactMeta.getMd5() );
1146             artifactMetadataModel.setSha1( artifactMeta.getSha1() );
1147             artifactMetadataModel.setVersion( artifactMeta.getVersion() );
1148         }
1149
1150         try
1151         {
1152             getArtifactMetadataModelEntityManager().put( artifactMetadataModel );
1153         }
1154         catch ( PersistenceException e )
1155         {
1156             throw new MetadataRepositoryException( e.getMessage(), e );
1157         }
1158
1159         key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repositoryId ).withNamespace(
1160             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
1161
1162         ProjectVersionMetadataModel projectVersionMetadataModel =
1163             getProjectVersionMetadataModelEntityManager().get( key );
1164
1165         if ( projectVersionMetadataModel == null )
1166         {
1167             projectVersionMetadataModel = new ProjectVersionMetadataModel();
1168             projectVersionMetadataModel.setRowId( key );
1169             projectVersionMetadataModel.setProjectId( projectId );
1170             projectVersionMetadataModel.setId( projectVersion );
1171             projectVersionMetadataModel.setNamespace( namespace );
1172
1173             getProjectVersionMetadataModelEntityManager().put( projectVersionMetadataModel );
1174
1175         }
1176
1177         // now facets
1178         updateFacets( artifactMeta, artifactMetadataModel );*/
1179
1180     }
1181
1182     @Override
1183     public Collection<String> getArtifactVersions( final String repoId, final String namespace, final String projectId,
1184                                                    final String projectVersion )
1185         throws MetadataResolutionException
1186     {
1187         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
1188
1189         QueryResult<OrderedRows<String, String, String>> result = HFactory //
1190             .createRangeSlicesQuery( keyspace, //
1191                                      StringSerializer.get(), //
1192                                      StringSerializer.get(), //
1193                                      StringSerializer.get() ) //
1194             .setColumnFamily( cassandraArchivaManager.getArtifactMetadataModelFamilyName() ) //
1195             .setColumnNames( "version" ) //
1196             .addEqualsExpression( "repositoryName", repoId ) //
1197             .addEqualsExpression( "namespaceId", namespace ) //
1198             .addEqualsExpression( "projectId", projectId ) //
1199             .addEqualsExpression( "projectVersion", projectVersion ).execute();
1200
1201         final Set<String> versions = new HashSet<String>();
1202
1203         for ( Row<String, String, String> row : result.get() )
1204         {
1205             versions.add( row.getColumnSlice().getColumnByName( "version" ).getValue() );
1206         }
1207
1208         return versions;
1209
1210 /*        final Set<String> versions = new HashSet<String>();
1211         // FIXME use cql query
1212         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1213         {
1214             @Override
1215             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1216             {
1217                 if ( artifactMetadataModel != null )
1218                 {
1219                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1220                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1221                                                                                                  artifactMetadataModel.getProject() )
1222                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1223                     {
1224                         versions.add( artifactMetadataModel.getVersion() );
1225                     }
1226                 }
1227                 return Boolean.TRUE;
1228             }
1229         } );
1230
1231         return versions;*/
1232
1233     }
1234
1235     /**
1236      * iterate over available facets to remove/add from the artifactMetadata
1237      *
1238      * @param facetedMetadata
1239      * @param artifactMetadataModel only use for the key
1240      */
1241     private void updateFacets( final FacetedMetadata facetedMetadata,
1242                                final ArtifactMetadataModel artifactMetadataModel )
1243     {
1244
1245 /*        for ( final String facetId : metadataFacetFactories.keySet() )
1246         {
1247             MetadataFacet metadataFacet = facetedMetadata.getFacet( facetId );
1248             if ( metadataFacet == null )
1249             {
1250                 continue;
1251             }
1252             // clean first
1253
1254             final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1255
1256             getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1257             {
1258                 @Override
1259                 public Boolean apply( MetadataFacetModel metadataFacetModel )
1260                 {
1261                     ArtifactMetadataModel tmp = metadataFacetModel.getArtifactMetadataModel();
1262                     if ( StringUtils.equals( metadataFacetModel.getFacetId(), facetId ) && StringUtils.equals(
1263                         tmp.getRepositoryId(), artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1264                         tmp.getNamespace(), artifactMetadataModel.getNamespace() ) && StringUtils.equals(
1265                         tmp.getProject(), artifactMetadataModel.getProject() ) )
1266                     {
1267                         metadataFacetModels.add( metadataFacetModel );
1268                     }
1269                     return Boolean.TRUE;
1270                 }
1271             } );
1272
1273             getMetadataFacetModelEntityManager().remove( metadataFacetModels );
1274
1275             Map<String, String> properties = metadataFacet.toProperties();
1276
1277             final List<MetadataFacetModel> metadataFacetModelsToAdd =
1278                 new ArrayList<MetadataFacetModel>( properties.size() );
1279
1280             for ( Map.Entry<String, String> entry : properties.entrySet() )
1281             {
1282                 String key = new MetadataFacetModel.KeyBuilder().withKey( entry.getKey() ).withArtifactMetadataModel(
1283                     artifactMetadataModel ).withFacetId( facetId ).withName( metadataFacet.getName() ).build();
1284                 MetadataFacetModel metadataFacetModel =
1285                     new MetadataFacetModel( key, artifactMetadataModel, facetId, entry.getKey(), entry.getValue(),
1286                                             metadataFacet.getName() );
1287                 metadataFacetModelsToAdd.add( metadataFacetModel );
1288             }
1289
1290             getMetadataFacetModelEntityManager().put( metadataFacetModelsToAdd );
1291         }*/
1292     }
1293
1294
1295     @Override
1296     public List<String> getMetadataFacets( final String repositoryId, final String facetId )
1297         throws MetadataRepositoryException
1298     {
1299
1300         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
1301
1302         QueryResult<OrderedRows<String, String, String>> result = HFactory //
1303             .createRangeSlicesQuery( keyspace, //
1304                                      StringSerializer.get(), //
1305                                      StringSerializer.get(), //
1306                                      StringSerializer.get() ) //
1307             .setColumnFamily( cassandraArchivaManager.getMetadataFacetModelFamilyName() ) //
1308             .setColumnNames( "name" ) //
1309             .addEqualsExpression( "repositoryName", repositoryId ) //
1310             .addEqualsExpression( "facetId", facetId ) //
1311             .execute();
1312
1313         final List<String> facets = new ArrayList<String>();
1314
1315         for ( Row<String, String, String> row : result.get() )
1316         {
1317             facets.add( row.getColumnSlice().getColumnByName( "name" ).getValue() );
1318         }
1319         return facets;
1320     }
1321
1322     @Override
1323     public boolean hasMetadataFacet( String repositoryId, String facetId )
1324         throws MetadataRepositoryException
1325     {
1326         return !getMetadataFacets( repositoryId, facetId ).isEmpty();
1327     }
1328
1329     @Override
1330     public MetadataFacet getMetadataFacet( final String repositoryId, final String facetId, final String name )
1331         throws MetadataRepositoryException
1332     {
1333
1334         MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( facetId );
1335         if ( metadataFacetFactory == null )
1336         {
1337             return null;
1338         }
1339
1340         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
1341
1342         QueryResult<OrderedRows<String, String, String>> result = HFactory //
1343             .createRangeSlicesQuery( keyspace, //
1344                                      StringSerializer.get(), //
1345                                      StringSerializer.get(), //
1346                                      StringSerializer.get() ) //
1347             .setColumnFamily( cassandraArchivaManager.getMetadataFacetModelFamilyName() ) //
1348             .setColumnNames( "key", "value" ) //
1349             .addEqualsExpression( "repositoryName", repositoryId ) //
1350             .addEqualsExpression( "facetId", facetId ) //
1351             .addEqualsExpression( "name", name ) //
1352             .execute();
1353
1354         MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repositoryId, name );
1355         Map<String, String> map = new HashMap<String, String>( result.get().getCount() );
1356         for ( Row<String, String, String> row : result.get() )
1357         {
1358             ColumnSlice<String, String> columnSlice = row.getColumnSlice();
1359             map.put( columnSlice.getColumnByName( "key" ).getValue(),
1360                      columnSlice.getColumnByName( "value" ).getValue() );
1361         }
1362         metadataFacet.fromProperties( map );
1363         return metadataFacet;
1364
1365
1366 /*
1367         final List<MetadataFacetModel> facets = new ArrayList<MetadataFacetModel>();
1368         this.getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1369         {
1370             @Override
1371             public Boolean apply( MetadataFacetModel metadataFacetModel )
1372             {
1373                 if ( metadataFacetModel != null )
1374                 {
1375                     if ( StringUtils.equals( metadataFacetModel.getArtifactMetadataModel().getRepositoryId(),
1376                                              repositoryId ) && StringUtils.equals( metadataFacetModel.getFacetId(),
1377                                                                                    facetId ) && StringUtils.equals(
1378                         metadataFacetModel.getName(), name ) )
1379                     {
1380                         facets.add( metadataFacetModel );
1381                     }
1382                 }
1383                 return Boolean.TRUE;
1384             }
1385         } );
1386
1387         if ( facets.isEmpty() )
1388         {
1389             return null;
1390         }
1391
1392         MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( facetId );
1393         if ( metadataFacetFactory == null )
1394         {
1395             return null;
1396         }
1397         MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repositoryId, name );
1398         Map<String, String> map = new HashMap<String, String>( facets.size() );
1399         for ( MetadataFacetModel metadataFacetModel : facets )
1400         {
1401             map.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
1402         }
1403         metadataFacet.fromProperties( map );
1404         return metadataFacet;*/
1405     }
1406
1407     @Override
1408     public void addMetadataFacet( String repositoryId, MetadataFacet metadataFacet )
1409         throws MetadataRepositoryException
1410     {
1411
1412         if ( metadataFacet == null )
1413         {
1414             return;
1415         }
1416
1417         if ( metadataFacet.toProperties().isEmpty() )
1418         {
1419             String key = new MetadataFacetModel.KeyBuilder().withRepositoryId( repositoryId ).withFacetId(
1420                 metadataFacet.getFacetId() ).withName( metadataFacet.getName() ).build();
1421
1422             boolean exists = this.metadataFacetTemplate.isColumnsExist( key );
1423
1424             if ( exists )
1425             {
1426                 ColumnFamilyUpdater<String, String> updater = this.metadataFacetTemplate.createUpdater( key );
1427                 updater.setString( "facetId", metadataFacet.getFacetId() );
1428                 updater.setString( "name", metadataFacet.getName() );
1429                 this.metadataFacetTemplate.update( updater );
1430             }
1431             else
1432             {
1433                 String cf = this.cassandraArchivaManager.getMetadataFacetModelFamilyName();
1434                 this.metadataFacetTemplate.createMutator() //
1435                     .addInsertion( key, cf, column( "repositoryName", repositoryId ) ) //
1436                     .addInsertion( key, cf, column( "facetId", metadataFacet.getFacetId() ) ) //
1437                     .addInsertion( key, cf, column( "name", metadataFacet.getName() ) ) //
1438                     .execute();
1439             }
1440
1441         }
1442         else
1443         {
1444             for ( Map.Entry<String, String> entry : metadataFacet.toProperties().entrySet() )
1445             {
1446
1447                 String key = new MetadataFacetModel.KeyBuilder().withRepositoryId( repositoryId ).withFacetId(
1448                     metadataFacet.getFacetId() ).withName( metadataFacet.getName() ).withKey( entry.getKey() ).build();
1449
1450                 boolean exists = this.metadataFacetTemplate.isColumnsExist( key );
1451                 if ( !exists )
1452                 {
1453                     //metadataFacetModel = new MetadataFacetModel();
1454                     // we need to store the repositoryId
1455                     //ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1456                     //artifactMetadataModel.setRepositoryId( repositoryId );
1457                     //metadataFacetModel.setArtifactMetadataModel( artifactMetadataModel );
1458                     //metadataFacetModel.setId( key );
1459                     //metadataFacetModel.setKey( entry.getKey() );
1460                     //metadataFacetModel.setFacetId( metadataFacet.getFacetId() );
1461                     //metadataFacetModel.setName( metadataFacet.getName() );
1462
1463                     String cf = this.cassandraArchivaManager.getMetadataFacetModelFamilyName();
1464                     this.metadataFacetTemplate.createMutator() //
1465                         .addInsertion( key, cf, column( "repositoryName", repositoryId ) ) //
1466                         .addInsertion( key, cf, column( "facetId", metadataFacet.getFacetId() ) ) //
1467                         .addInsertion( key, cf, column( "name", metadataFacet.getName() ) ) //
1468                         .addInsertion( key, cf, column( "key", entry.getKey() ) ) //
1469                         .addInsertion( key, cf, column( "value", entry.getValue() ) ) //
1470                         .execute();
1471
1472                 }
1473                 else
1474                 {
1475                     ColumnFamilyUpdater<String, String> updater = this.metadataFacetTemplate.createUpdater( key );
1476                     updater.setString( "value", entry.getValue() );
1477                     this.metadataFacetTemplate.update( updater );
1478                 }
1479             }
1480         }
1481     }
1482
1483     @Override
1484     public void removeMetadataFacets( final String repositoryId, final String facetId )
1485         throws MetadataRepositoryException
1486     {
1487         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
1488
1489         QueryResult<OrderedRows<String, String, String>> result = HFactory //
1490             .createRangeSlicesQuery( keyspace, //
1491                                      StringSerializer.get(), //
1492                                      StringSerializer.get(), //
1493                                      StringSerializer.get() ) //
1494             .setColumnFamily( cassandraArchivaManager.getMetadataFacetModelFamilyName() ) //
1495             .setColumnNames( "key", "value" ) //
1496             .addEqualsExpression( "repositoryName", repositoryId ) //
1497             .addEqualsExpression( "facetId", facetId ) //
1498             .execute();
1499
1500         for ( Row<String, String, String> row : result.get() )
1501         {
1502             this.metadataFacetTemplate.deleteRow( row.getKey() );
1503         }
1504
1505     }
1506
1507     @Override
1508     public void removeMetadataFacet( final String repositoryId, final String facetId, final String name )
1509         throws MetadataRepositoryException
1510     {
1511         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
1512
1513         QueryResult<OrderedRows<String, String, String>> result = HFactory //
1514             .createRangeSlicesQuery( keyspace, //
1515                                      StringSerializer.get(), //
1516                                      StringSerializer.get(), //
1517                                      StringSerializer.get() ) //
1518             .setColumnFamily( cassandraArchivaManager.getMetadataFacetModelFamilyName() ) //
1519             .setColumnNames( "key", "value" ) //
1520             .addEqualsExpression( "repositoryName", repositoryId ) //
1521             .addEqualsExpression( "facetId", facetId ) //
1522             .addEqualsExpression( "name", name ) //
1523             .execute();
1524
1525         for ( Row<String, String, String> row : result.get() )
1526         {
1527             this.metadataFacetTemplate.deleteRow( row.getKey() );
1528         }
1529     }
1530
1531     @Override
1532     public List<ArtifactMetadata> getArtifactsByDateRange( final String repositoryId, final Date startTime,
1533                                                            final Date endTime )
1534         throws MetadataRepositoryException
1535     {
1536
1537         Keyspace keyspace = cassandraArchivaManager.getKeyspace();
1538
1539         // FIXME cql query to filter in repositoryName column
1540         /*
1541         QueryResult<OrderedRows<String, String, Long>> result = HFactory //
1542             .createRangeSlicesQuery( keyspace, //
1543                                      StringSerializer.get(), //
1544                                      StringSerializer.get(), //
1545                                      LongSerializer.get() ) //
1546
1547             .setColumnFamily( cassandraArchivaManager.getArtifactMetadataModelFamilyName() ) //
1548             .setColumnNames( "whenGathered", "repositoryName" ) //
1549             .addGteExpression( "whenGathered", startTime.getTime() ) //
1550             .addLteExpression( "whenGathered", endTime.getTime() )
1551             .execute();
1552         */
1553         StringSerializer ss = StringSerializer.get();
1554         CqlQuery<String,String,String> cqlQuery = new CqlQuery<String,String,String>(keyspace, ss, ss, ss);
1555         cqlQuery.setQuery("select * from " + cassandraArchivaManager.getArtifactMetadataModelFamilyName() //
1556                               + " where 'whenGathered' >= " + startTime.getTime() //
1557                               + " and 'whenGathered' <= " + endTime.getTime() //
1558                               + " and respositoryName = '" + repositoryId + "'");
1559         QueryResult<CqlRows<String,String,String>> result = cqlQuery.execute();
1560         List<String> keys = new ArrayList<String>( result.get().getCount() );
1561
1562         for (Row<String,String,String> row : result.get())
1563         {
1564             keys.add( row.getKey() );
1565         }
1566
1567
1568
1569 /*        final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1570
1571         // FIXME cql query
1572         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1573         {
1574             @Override
1575             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1576             {
1577                 if ( artifactMetadataModel != null )
1578                 {
1579                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
1580                         && artifactMetadataModel.getNamespace() != null &&
1581                         artifactMetadataModel.getProject() != null && artifactMetadataModel.getId() != null )
1582                     {
1583
1584                         Date when = artifactMetadataModel.getWhenGathered();
1585                         if ( ( startTime != null ? when.getTime() >= startTime.getTime() : true ) && ( endTime != null ?
1586                             when.getTime() <= endTime.getTime() : true ) )
1587                         {
1588                             logger.debug( "getArtifactsByDateRange visitAll found: {}", artifactMetadataModel );
1589                             artifactMetadataModels.add( artifactMetadataModel );
1590                         }
1591                     }
1592                 }
1593                 return Boolean.TRUE;
1594             }
1595         } );
1596         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1597
1598         for ( ArtifactMetadataModel model : artifactMetadataModels )
1599         {
1600             ArtifactMetadata artifactMetadata = getModelMapper().map( model, ArtifactMetadata.class );
1601             populateFacets( artifactMetadata );
1602             artifactMetadatas.add( artifactMetadata );
1603         }
1604
1605         // FIXME facets ?
1606
1607         logger.debug( "getArtifactsByDateRange repositoryId: {}, startTime: {}, endTime: {}, artifactMetadatas: {}",
1608                       repositoryId, startTime, endTime, artifactMetadatas );
1609
1610         return artifactMetadatas;*/
1611         return Collections.emptyList();
1612     }
1613
1614     protected void populateFacets( final ArtifactMetadata artifactMetadata )
1615     {
1616 /*        final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1617
1618         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1619         {
1620             @Override
1621             public Boolean apply( MetadataFacetModel metadataFacetModel )
1622             {
1623                 if ( metadataFacetModel != null )
1624                 {
1625                     ArtifactMetadataModel artifactMetadataModel = metadataFacetModel.getArtifactMetadataModel();
1626                     if ( artifactMetadataModel != null )
1627                     {
1628                         if ( StringUtils.equals( artifactMetadata.getRepositoryId(),
1629                                                  artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1630                             artifactMetadata.getNamespace(), artifactMetadataModel.getNamespace() )
1631                             && StringUtils.equals( artifactMetadata.getRepositoryId(),
1632                                                    artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1633                             artifactMetadata.getProject(), artifactMetadataModel.getProject() ) && StringUtils.equals(
1634                             artifactMetadata.getId(), artifactMetadataModel.getId() ) )
1635                         {
1636                             metadataFacetModels.add( metadataFacetModel );
1637                         }
1638                     }
1639                 }
1640                 return Boolean.TRUE;
1641             }
1642         } );
1643         Map<String, Map<String, String>> facetValuesPerFacet = new HashMap<String, Map<String, String>>();
1644
1645         for ( MetadataFacetModel model : metadataFacetModels )
1646         {
1647             Map<String, String> values = facetValuesPerFacet.get( model.getName() );
1648             if ( values == null )
1649             {
1650                 values = new HashMap<String, String>();
1651             }
1652             values.put( model.getKey(), model.getValue() );
1653             facetValuesPerFacet.put( model.getName(), values );
1654         }
1655
1656         for ( Map.Entry<String, Map<String, String>> entry : facetValuesPerFacet.entrySet() )
1657         {
1658             MetadataFacetFactory factory = metadataFacetFactories.get( entry.getKey() );
1659             if ( factory == null )
1660             {
1661                 continue;
1662             }
1663             MetadataFacet metadataFacet =
1664                 factory.createMetadataFacet( artifactMetadata.getRepositoryId(), entry.getKey() );
1665             metadataFacet.fromProperties( entry.getValue() );
1666             artifactMetadata.addFacet( metadataFacet );
1667         }*/
1668     }
1669
1670     @Override
1671     public List<ArtifactMetadata> getArtifactsByChecksum( final String repositoryId, final String checksum )
1672         throws MetadataRepositoryException
1673     {
1674 /*        final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1675
1676         if ( logger.isDebugEnabled() )
1677         {
1678             logger.debug( "all ArtifactMetadataModel: {}", getArtifactMetadataModelEntityManager().getAll() );
1679         }
1680
1681         // FIXME cql query
1682         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1683         {
1684             @Override
1685             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1686             {
1687                 if ( artifactMetadataModel != null )
1688                 {
1689                     if ( StringUtils.equals( artifactMetadataModel.getRepositoryId(), repositoryId )
1690                         && artifactMetadataModel.getNamespace() != null &&
1691                         artifactMetadataModel.getProject() != null && artifactMetadataModel.getId() != null )
1692                     {
1693
1694                         if ( StringUtils.equals( checksum, artifactMetadataModel.getMd5() ) || StringUtils.equals(
1695                             checksum, artifactMetadataModel.getSha1() ) )
1696                         {
1697                             artifactMetadataModels.add( artifactMetadataModel );
1698                         }
1699                     }
1700                 }
1701                 return Boolean.TRUE;
1702             }
1703         } );
1704         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1705
1706         for ( ArtifactMetadataModel model : artifactMetadataModels )
1707         {
1708             ArtifactMetadata artifactMetadata = getModelMapper().map( model, ArtifactMetadata.class );
1709             populateFacets( artifactMetadata );
1710             artifactMetadatas.add( artifactMetadata );
1711         }
1712
1713         logger.debug( "getArtifactsByChecksum repositoryId: {}, checksum: {}, artifactMetadatas: {}", repositoryId,
1714                       checksum, artifactMetadatas );
1715
1716         return artifactMetadatas;*/
1717         return Collections.emptyList();
1718     }
1719
1720     @Override
1721     public void removeArtifact( final String repositoryId, final String namespace, final String project,
1722                                 final String version, final String id )
1723         throws MetadataRepositoryException
1724     {
1725 /*        logger.debug( "removeArtifact repositoryId: '{}', namespace: '{}', project: '{}', version: '{}', id: '{}'",
1726                       repositoryId, namespace, project, version, id );
1727         String key =
1728             new ArtifactMetadataModel.KeyBuilder().withRepositoryId( repositoryId ).withNamespace( namespace ).withId(
1729                 id ).withProjectVersion( version ).withProject( project ).build();
1730
1731         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1732         artifactMetadataModel.setArtifactMetadataModelId( key );
1733
1734         getArtifactMetadataModelEntityManager().remove( artifactMetadataModel );
1735
1736         key =
1737             new ProjectVersionMetadataModel.KeyBuilder().withId( version ).withRepository( repositoryId ).withNamespace(
1738                 namespace ).withProjectId( project ).build();
1739
1740         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1741         projectVersionMetadataModel.setRowId( key );
1742
1743         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModel );*/
1744     }
1745
1746     @Override
1747     public void removeArtifact( ArtifactMetadata artifactMetadata, String baseVersion )
1748         throws MetadataRepositoryException
1749     {
1750         logger.debug( "removeArtifact repositoryId: '{}', namespace: '{}', project: '{}', version: '{}', id: '{}'",
1751                       artifactMetadata.getRepositoryId(), artifactMetadata.getNamespace(),
1752                       artifactMetadata.getProject(), baseVersion, artifactMetadata.getId() );
1753 /*        String key =
1754             new ArtifactMetadataModel.KeyBuilder().withRepositoryId( artifactMetadata.getRepositoryId() ).withNamespace(
1755                 artifactMetadata.getNamespace() ).withId( artifactMetadata.getId() ).withProjectVersion(
1756                 baseVersion ).withProject( artifactMetadata.getProject() ).build();
1757
1758         ArtifactMetadataModel artifactMetadataModel = new ArtifactMetadataModel();
1759         artifactMetadataModel.setArtifactMetadataModelId( key );
1760
1761         getArtifactMetadataModelEntityManager().remove( artifactMetadataModel );*/
1762     }
1763
1764     @Override
1765     public void removeArtifact( final String repositoryId, final String namespace, final String project,
1766                                 final String version, final MetadataFacet metadataFacet )
1767         throws MetadataRepositoryException
1768     {
1769
1770
1771
1772 /*        final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1773         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1774         {
1775             @Override
1776             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1777             {
1778                 if ( artifactMetadataModel != null )
1779                 {
1780                     if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() )
1781                         && StringUtils.equals( namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals(
1782                         project, artifactMetadataModel.getProject() ) && StringUtils.equals( project,
1783                                                                                              artifactMetadataModel.getVersion() ) )
1784                     {
1785                         artifactMetadataModels.add( artifactMetadataModel );
1786                     }
1787                 }
1788                 return Boolean.TRUE;
1789             }
1790         } );
1791         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );*/
1792
1793     }
1794
1795
1796     @Override
1797     public List<ArtifactMetadata> getArtifacts( final String repositoryId )
1798         throws MetadataRepositoryException
1799     {
1800 /*        final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1801         // FIXME use cql query !
1802         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1803         {
1804             @Override
1805             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1806            {
1807                 if ( artifactMetadataModel != null )
1808                 {
1809                     if ( StringUtils.equals( repositoryId, artifactMetadataModel.getRepositoryId() ) )
1810                     {
1811                         artifactMetadataModels.add( artifactMetadataModel );
1812                     }
1813                 }
1814
1815                 return Boolean.TRUE;
1816             }
1817         } );
1818
1819         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
1820
1821         for ( ArtifactMetadataModel model : artifactMetadataModels )
1822         {
1823             ArtifactMetadata artifactMetadata = getModelMapper().map( model, ArtifactMetadata.class );
1824             populateFacets( artifactMetadata );
1825             artifactMetadatas.add( artifactMetadata );
1826         }
1827
1828         return artifactMetadatas;*/
1829         return Collections.emptyList();
1830     }
1831
1832
1833     @Override
1834     public ProjectVersionMetadata getProjectVersion( final String repoId, final String namespace,
1835                                                      final String projectId, final String projectVersion )
1836         throws MetadataResolutionException
1837     {
1838 /*        String key = new ProjectVersionMetadataModel.KeyBuilder().withRepository( repoId ).withNamespace(
1839             namespace ).withProjectId( projectId ).withId( projectVersion ).build();
1840
1841         ProjectVersionMetadataModel projectVersionMetadataModel =
1842             getProjectVersionMetadataModelEntityManager().get( key );
1843
1844         if ( projectVersionMetadataModel == null )
1845         {
1846             logger.debug(
1847                 "getProjectVersion repoId: '{}', namespace: '{}', projectId: '{}', projectVersion: {} -> not found",
1848                 repoId, namespace, projectId, projectVersion );
1849             return null;
1850         }
1851
1852         ProjectVersionMetadata projectVersionMetadata =
1853             getModelMapper().map( projectVersionMetadataModel, ProjectVersionMetadata.class );
1854
1855         logger.debug( "getProjectVersion repoId: '{}', namespace: '{}', projectId: '{}', projectVersion: {} -> {}",
1856                       repoId, namespace, projectId, projectVersion, projectVersionMetadata );
1857
1858         projectVersionMetadata.setCiManagement( projectVersionMetadataModel.getCiManagement() );
1859         projectVersionMetadata.setIssueManagement( projectVersionMetadataModel.getIssueManagement() );
1860         projectVersionMetadata.setOrganization( projectVersionMetadataModel.getOrganization() );
1861         projectVersionMetadata.setScm( projectVersionMetadataModel.getScm() );
1862
1863         // FIXME complete collections !!
1864
1865         // facets
1866         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
1867         // FIXME use cql query
1868         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
1869         {
1870             @Override
1871             public Boolean apply( MetadataFacetModel metadataFacetModel )
1872             {
1873                 if ( metadataFacetModel != null )
1874                 {
1875                     if ( StringUtils.equals( repoId, metadataFacetModel.getArtifactMetadataModel().getRepositoryId() )
1876                         && StringUtils.equals( namespace, metadataFacetModel.getArtifactMetadataModel().getNamespace() )
1877                         && StringUtils.equals( projectId, metadataFacetModel.getArtifactMetadataModel().getProject() )
1878                         && StringUtils.equals( projectVersion,
1879                                                metadataFacetModel.getArtifactMetadataModel().getProjectVersion() ) )
1880                     {
1881                         metadataFacetModels.add( metadataFacetModel );
1882                     }
1883                 }
1884                 return Boolean.TRUE;
1885             }
1886         } );
1887         Map<String, Map<String, String>> metadataFacetsPerFacetIds = new HashMap<String, Map<String, String>>();
1888         for ( MetadataFacetModel metadataFacetModel : metadataFacetModels )
1889         {
1890
1891             Map<String, String> metaValues = metadataFacetsPerFacetIds.get( metadataFacetModel.getFacetId() );
1892             if ( metaValues == null )
1893             {
1894                 metaValues = new HashMap<String, String>();
1895                 metadataFacetsPerFacetIds.put( metadataFacetModel.getFacetId(), metaValues );
1896             }
1897             metaValues.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
1898
1899         }
1900
1901         if ( !metadataFacetsPerFacetIds.isEmpty() )
1902         {
1903             for ( Map.Entry<String, Map<String, String>> entry : metadataFacetsPerFacetIds.entrySet() )
1904             {
1905                 MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( entry.getKey() );
1906                 if ( metadataFacetFactory != null )
1907                 {
1908                     MetadataFacet metadataFacet = metadataFacetFactory.createMetadataFacet( repoId, entry.getKey() );
1909                     metadataFacet.fromProperties( entry.getValue() );
1910                     projectVersionMetadata.addFacet( metadataFacet );
1911                 }
1912             }
1913         }
1914
1915         return projectVersionMetadata;*/
1916         return null;
1917     }
1918
1919
1920     @Override
1921     public Collection<ProjectVersionReference> getProjectReferences( String repoId, String namespace, String projectId,
1922                                                                      String projectVersion )
1923         throws MetadataResolutionException
1924     {
1925         // FIXME implement this
1926         return Collections.emptyList();
1927     }
1928
1929     @Override
1930     public void removeProjectVersion( final String repoId, final String namespace, final String projectId,
1931                                       final String projectVersion )
1932         throws MetadataRepositoryException
1933     {
1934         /*
1935         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1936
1937         // FIXME use cql query
1938
1939         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1940         {
1941             @Override
1942             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1943             {
1944                 if ( artifactMetadataModel != null )
1945                 {
1946                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1947                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1948                                                                                                  artifactMetadataModel.getProject() )
1949                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1950                     {
1951                         artifactMetadataModels.add( artifactMetadataModel );
1952                     }
1953                 }
1954                 return Boolean.TRUE;
1955             }
1956         } );
1957
1958         logger.debug( "removeProjectVersions:{}", artifactMetadataModels );
1959         if ( artifactMetadataModels.isEmpty() )
1960         {
1961             return;
1962         }
1963
1964         getArtifactMetadataModelEntityManager().remove( artifactMetadataModels );
1965
1966         String key = new ProjectVersionMetadataModel.KeyBuilder().withProjectId( projectId ).withId(
1967             projectVersion ).withRepository( repoId ).withNamespace( namespace ).build();
1968
1969         ProjectVersionMetadataModel projectVersionMetadataModel = new ProjectVersionMetadataModel();
1970         projectVersionMetadataModel.setRowId( key );
1971
1972         getProjectVersionMetadataModelEntityManager().remove( projectVersionMetadataModel );
1973         */
1974     }
1975
1976     @Override
1977     public Collection<ArtifactMetadata> getArtifacts( final String repoId, final String namespace,
1978                                                       final String projectId, final String projectVersion )
1979         throws MetadataResolutionException
1980     {
1981         final List<ArtifactMetadataModel> artifactMetadataModels = new ArrayList<ArtifactMetadataModel>();
1982         /*
1983         // FIXME use cql query !
1984         getArtifactMetadataModelEntityManager().visitAll( new Function<ArtifactMetadataModel, Boolean>()
1985         {
1986             @Override
1987             public Boolean apply( ArtifactMetadataModel artifactMetadataModel )
1988             {
1989                 if ( artifactMetadataModel != null )
1990                 {
1991                     if ( StringUtils.equals( repoId, artifactMetadataModel.getRepositoryId() ) && StringUtils.equals(
1992                         namespace, artifactMetadataModel.getNamespace() ) && StringUtils.equals( projectId,
1993                                                                                                  artifactMetadataModel.getProject() )
1994                         && StringUtils.equals( projectVersion, artifactMetadataModel.getProjectVersion() ) )
1995                     {
1996                         artifactMetadataModels.add( artifactMetadataModel );
1997                     }
1998                 }
1999
2000                 return Boolean.TRUE;
2001             }
2002         } );
2003         */
2004         List<ArtifactMetadata> artifactMetadatas = new ArrayList<ArtifactMetadata>( artifactMetadataModels.size() );
2005         /*
2006         for ( ArtifactMetadataModel model : artifactMetadataModels )
2007         {
2008             ArtifactMetadata artifactMetadata = getModelMapper().map( model, ArtifactMetadata.class );
2009             populateFacets( artifactMetadata );
2010             artifactMetadatas.add( artifactMetadata );
2011         }
2012
2013         // retrieve facets
2014         final List<MetadataFacetModel> metadataFacetModels = new ArrayList<MetadataFacetModel>();
2015         getMetadataFacetModelEntityManager().visitAll( new Function<MetadataFacetModel, Boolean>()
2016         {
2017             @Override
2018             public Boolean apply( MetadataFacetModel metadataFacetModel )
2019             {
2020                 if ( metadataFacetModel != null )
2021                 {
2022                     if ( StringUtils.equals( repoId, metadataFacetModel.getArtifactMetadataModel().getRepositoryId() )
2023                         && StringUtils.equals( namespace, metadataFacetModel.getArtifactMetadataModel().getNamespace() )
2024                         && StringUtils.equals( projectId, metadataFacetModel.getArtifactMetadataModel().getProject() )
2025                         && StringUtils.equals( projectVersion,
2026                                                metadataFacetModel.getArtifactMetadataModel().getProjectVersion() ) )
2027                     {
2028                         metadataFacetModels.add( metadataFacetModel );
2029                     }
2030
2031                 }
2032                 return Boolean.TRUE;
2033             }
2034         } );
2035
2036         // rebuild MetadataFacet for artifacts
2037
2038         for ( final ArtifactMetadata artifactMetadata : artifactMetadatas )
2039         {
2040             Iterable<MetadataFacetModel> metadataFacetModelIterable =
2041                 Iterables.filter( metadataFacetModels, new Predicate<MetadataFacetModel>()
2042                 {
2043                     @Override
2044                     public boolean apply( MetadataFacetModel metadataFacetModel )
2045                     {
2046                         if ( metadataFacetModel != null )
2047                         {
2048                             return StringUtils.equals( artifactMetadata.getVersion(),
2049                                                        metadataFacetModel.getArtifactMetadataModel().getVersion() );
2050                         }
2051                         return false;
2052                     }
2053                 } );
2054             Iterator<MetadataFacetModel> iterator = metadataFacetModelIterable.iterator();
2055             Map<String, List<MetadataFacetModel>> metadataFacetValuesPerFacetId =
2056                 new HashMap<String, List<MetadataFacetModel>>();
2057             while ( iterator.hasNext() )
2058             {
2059                 MetadataFacetModel metadataFacetModel = iterator.next();
2060                 List<MetadataFacetModel> values = metadataFacetValuesPerFacetId.get( metadataFacetModel.getName() );
2061                 if ( values == null )
2062                 {
2063                     values = new ArrayList<MetadataFacetModel>();
2064                     metadataFacetValuesPerFacetId.put( metadataFacetModel.getFacetId(), values );
2065                 }
2066                 values.add( metadataFacetModel );
2067
2068             }
2069
2070             for ( Map.Entry<String, List<MetadataFacetModel>> entry : metadataFacetValuesPerFacetId.entrySet() )
2071             {
2072                 MetadataFacetFactory metadataFacetFactory = metadataFacetFactories.get( entry.getKey() );
2073                 if ( metadataFacetFactory != null )
2074                 {
2075                     List<MetadataFacetModel> facetModels = entry.getValue();
2076                     if ( !facetModels.isEmpty() )
2077                     {
2078                         MetadataFacet metadataFacet =
2079                             metadataFacetFactory.createMetadataFacet( repoId, facetModels.get( 0 ).getName() );
2080                         Map<String, String> props = new HashMap<String, String>( facetModels.size() );
2081                         for ( MetadataFacetModel metadataFacetModel : facetModels )
2082                         {
2083                             props.put( metadataFacetModel.getKey(), metadataFacetModel.getValue() );
2084                         }
2085                         metadataFacet.fromProperties( props );
2086                         artifactMetadata.addFacet( metadataFacet );
2087                     }
2088                 }
2089             }
2090
2091
2092         }
2093         */
2094         return artifactMetadatas;
2095     }
2096
2097     @Override
2098     public void save()
2099     {
2100         logger.trace( "save" );
2101     }
2102
2103     @Override
2104     public void close()
2105         throws MetadataRepositoryException
2106     {
2107         logger.trace( "close" );
2108     }
2109
2110     @Override
2111     public void revert()
2112     {
2113         logger.warn( "CassandraMetadataRepository cannot revert" );
2114     }
2115
2116     @Override
2117     public boolean canObtainAccess( Class<?> aClass )
2118     {
2119         return false;
2120     }
2121
2122     @Override
2123     public <T> T obtainAccess( Class<T> aClass )
2124         throws MetadataRepositoryException
2125     {
2126         throw new IllegalArgumentException(
2127             "Access using " + aClass + " is not supported on the cassandra metadata storage" );
2128     }
2129
2130
2131     private static class ModelMapperHolder
2132     {
2133         private static ModelMapper MODEL_MAPPER = new ModelMapper();
2134     }
2135
2136     protected ModelMapper getModelMapper()
2137     {
2138         return ModelMapperHolder.MODEL_MAPPER;
2139     }
2140 }