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