EMMA Coverage Report (generated Sun Sep 18 11:34:27 PHT 2011)
[all classes][org.apache.continuum.dao]

COVERAGE SUMMARY FOR SOURCE FILE [ProjectDaoImpl.java]

nameclass, %method, %block, %line, %
ProjectDaoImpl.java100% (1/1)55%  (11/20)39%  (204/525)43%  (50.8/119)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ProjectDaoImpl100% (1/1)55%  (11/20)39%  (204/525)43%  (50.8/119)
getAllProjectsByNameWithBuildDetails (): List 0%   (0/1)0%   (0/6)0%   (0/1)
getAllProjectsByNameWithDependencies (): List 0%   (0/1)0%   (0/6)0%   (0/1)
getProject (String, String, String): Project 0%   (0/1)0%   (0/80)0%   (0/20)
getProjectByName (String): Project 0%   (0/1)0%   (0/65)0%   (0/16)
getProjectGroupByProjectId (int): ProjectGroup 0%   (0/1)0%   (0/18)0%   (0/3)
getProjectWithBuildDetails (int): Project 0%   (0/1)0%   (0/7)0%   (0/1)
getProjectWithDependencies (int): Project 0%   (0/1)0%   (0/7)0%   (0/1)
getProjectsInGroupWithDependencies (int): List 0%   (0/1)0%   (0/62)0%   (0/13)
getProjectsWithDependenciesByGroupId (int): List 0%   (0/1)0%   (0/54)0%   (0/11)
getProjectsSummary (): Map 100% (1/1)88%  (42/48)99%  (12.9/13)
getProjectsInGroup (int): List 100% (1/1)88%  (46/52)99%  (10.9/11)
processProjectGroupSummary (List): Map 100% (1/1)95%  (72/76)94%  (17/18)
ProjectDaoImpl (): void 100% (1/1)100% (3/3)100% (1/1)
getAllProjectsByName (): List 100% (1/1)100% (6/6)100% (1/1)
getProject (int): Project 100% (1/1)100% (6/6)100% (1/1)
getProjectWithAllDetails (int): Project 100% (1/1)100% (7/7)100% (1/1)
getProjectWithBuilds (int): Project 100% (1/1)100% (7/7)100% (1/1)
getProjectWithCheckoutResult (int): Project 100% (1/1)100% (7/7)100% (1/1)
removeProject (Project): void 100% (1/1)100% (4/4)100% (2/2)
updateProject (Project): void 100% (1/1)100% (4/4)100% (2/2)

1package org.apache.continuum.dao;
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 
22import java.util.Collection;
23import java.util.HashMap;
24import java.util.List;
25import java.util.Map;
26 
27import javax.jdo.Extent;
28import javax.jdo.PersistenceManager;
29import javax.jdo.Query;
30import javax.jdo.Transaction;
31 
32import org.apache.continuum.model.project.ProjectGroupSummary;
33import org.apache.continuum.model.project.ProjectSummaryResult;
34import org.apache.maven.continuum.model.project.Project;
35import org.apache.maven.continuum.model.project.ProjectGroup;
36import org.apache.maven.continuum.store.ContinuumObjectNotFoundException;
37import org.apache.maven.continuum.store.ContinuumStoreException;
38import org.springframework.stereotype.Repository;
39 
40/**
41 * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
42 * @version $Id: ProjectDaoImpl.java 788574 2009-06-26 04:51:32Z evenisse $
43 * @plexus.component role="org.apache.continuum.dao.ProjectDao"
44 */
45@Repository("projectDao")
46public class ProjectDaoImpl
47    extends AbstractDao
48    implements ProjectDao
49{
50    public void removeProject( Project project )
51    {
52        removeObject( project );
53    }
54 
55    public void updateProject( Project project )
56        throws ContinuumStoreException
57    {
58        updateObject( project );
59    }
60 
61    public Project getProject( int projectId )
62        throws ContinuumStoreException
63    {
64        return (Project) getObjectById( Project.class, projectId );
65    }
66 
67    public Project getProject( String groupId, String artifactId, String version )
68        throws ContinuumStoreException
69    {
70        PersistenceManager pm = getPersistenceManager();
71 
72        Transaction tx = pm.currentTransaction();
73 
74        try
75        {
76            tx.begin();
77 
78            Extent extent = pm.getExtent( Project.class, true );
79 
80            Query query = pm.newQuery( extent );
81 
82            query.declareImports( "import java.lang.String" );
83 
84            query.declareParameters( "String groupId, String artifactId, String version" );
85 
86            query.setFilter( "this.groupId == groupId && this.artifactId == artifactId && this.version == version" );
87 
88            Object[] params = new Object[3];
89            params[0] = groupId;
90            params[1] = artifactId;
91            params[2] = version;
92 
93            Collection result = (Collection) query.executeWithArray( params );
94 
95            if ( result.size() == 0 )
96            {
97                tx.commit();
98 
99                return null;
100            }
101 
102            Object object = pm.detachCopy( result.iterator().next() );
103 
104            tx.commit();
105 
106            return (Project) object;
107        }
108        finally
109        {
110            rollback( tx );
111        }
112    }
113 
114    public Project getProjectByName( String name )
115        throws ContinuumStoreException
116    {
117        PersistenceManager pm = getPersistenceManager();
118 
119        Transaction tx = pm.currentTransaction();
120 
121        try
122        {
123            tx.begin();
124 
125            Extent extent = pm.getExtent( Project.class, true );
126 
127            Query query = pm.newQuery( extent );
128 
129            query.declareImports( "import java.lang.String" );
130 
131            query.declareParameters( "String name" );
132 
133            query.setFilter( "this.name == name" );
134 
135            Collection result = (Collection) query.execute( name );
136 
137            if ( result.size() == 0 )
138            {
139                tx.commit();
140 
141                return null;
142            }
143 
144            Object object = pm.detachCopy( result.iterator().next() );
145 
146            tx.commit();
147 
148            return (Project) object;
149        }
150        finally
151        {
152            rollback( tx );
153        }
154    }
155 
156    public List<Project> getProjectsWithDependenciesByGroupId( int projectGroupId )
157    {
158        PersistenceManager pm = getPersistenceManager();
159 
160        Transaction tx = pm.currentTransaction();
161 
162        try
163        {
164            tx.begin();
165 
166            Extent extent = pm.getExtent( Project.class, true );
167 
168            Query query = pm.newQuery( extent, "projectGroup.id == " + projectGroupId );
169 
170            pm.getFetchPlan().addGroup( PROJECT_DEPENDENCIES_FETCH_GROUP );
171            List<Project> result = (List<Project>) query.execute();
172 
173            result = (List<Project>) pm.detachCopyAll( result );
174 
175            tx.commit();
176 
177            return result;
178        }
179        finally
180        {
181            rollback( tx );
182        }
183    }
184 
185    public Project getProjectWithBuilds( int projectId )
186        throws ContinuumStoreException
187    {
188        return (Project) getObjectById( Project.class, projectId, PROJECT_WITH_BUILDS_FETCH_GROUP );
189    }
190 
191    public Project getProjectWithBuildDetails( int projectId )
192        throws ContinuumStoreException
193    {
194        return (Project) getObjectById( Project.class, projectId, PROJECT_BUILD_DETAILS_FETCH_GROUP );
195    }
196 
197    public Project getProjectWithCheckoutResult( int projectId )
198        throws ContinuumStoreException
199    {
200        return (Project) getObjectById( Project.class, projectId, PROJECT_WITH_CHECKOUT_RESULT_FETCH_GROUP );
201    }
202 
203    public List<Project> getProjectsInGroup( int projectGroupId )
204        throws ContinuumStoreException
205    {
206        PersistenceManager pm = getPersistenceManager();
207 
208        Transaction tx = pm.currentTransaction();
209 
210        try
211        {
212            tx.begin();
213 
214            Extent extent = pm.getExtent( Project.class, true );
215 
216            Query query = pm.newQuery( extent, "projectGroup.id == " + projectGroupId );
217 
218            query.setOrdering( "name ascending" );
219 
220            List<Project> result = (List<Project>) query.execute();
221 
222            result = (List<Project>) pm.detachCopyAll( result );
223 
224            tx.commit();
225 
226            return result;
227        }
228        finally
229        {
230            rollback( tx );
231        }
232    }
233 
234    public List<Project> getProjectsInGroupWithDependencies( int projectGroupId )
235        throws ContinuumStoreException
236    {
237        PersistenceManager pm = getPersistenceManager();
238 
239        Transaction tx = pm.currentTransaction();
240 
241        try
242        {
243            tx.begin();
244 
245            Extent extent = pm.getExtent( Project.class, true );
246 
247            Query query = pm.newQuery( extent, "projectGroup.id == " + projectGroupId );
248 
249            query.setOrdering( "name ascending" );
250 
251            pm.getFetchPlan().addGroup( PROJECT_DEPENDENCIES_FETCH_GROUP );
252 
253            pm.getFetchPlan().addGroup( PROJECTGROUP_PROJECTS_FETCH_GROUP );
254 
255            List<Project> result = (List<Project>) query.execute();
256 
257            result = (List<Project>) pm.detachCopyAll( result );
258 
259            tx.commit();
260 
261            return result;
262        }
263        finally
264        {
265            rollback( tx );
266        }
267    }
268 
269    public Project getProjectWithAllDetails( int projectId )
270        throws ContinuumStoreException
271    {
272        return (Project) getObjectById( Project.class, projectId, PROJECT_ALL_DETAILS_FETCH_GROUP );
273    }
274 
275    public List<Project> getAllProjectsByName()
276    {
277        return getAllObjectsDetached( Project.class, "name ascending", null );
278    }
279 
280 
281    public List<Project> getAllProjectsByNameWithDependencies()
282    {
283        return getAllObjectsDetached( Project.class, "name ascending", PROJECT_DEPENDENCIES_FETCH_GROUP );
284    }
285 
286    public List<Project> getAllProjectsByNameWithBuildDetails()
287    {
288        return getAllObjectsDetached( Project.class, "name ascending", PROJECT_BUILD_DETAILS_FETCH_GROUP );
289    }
290 
291    public ProjectGroup getProjectGroupByProjectId( int projectId )
292        throws ContinuumObjectNotFoundException
293    {
294        try
295        {
296            return getProject( projectId ).getProjectGroup();
297        }
298        catch ( ContinuumStoreException e )
299        {
300            throw new ContinuumObjectNotFoundException(
301                "unable to find project group containing project with id: " + projectId );
302 
303        }
304    }
305 
306    public Project getProjectWithDependencies( int projectId )
307        throws ContinuumStoreException
308    {
309        return (Project) getObjectById( Project.class, projectId, PROJECT_DEPENDENCIES_FETCH_GROUP );
310    }
311 
312    public Map<Integer, ProjectGroupSummary> getProjectsSummary()
313    {
314        PersistenceManager pm = getPersistenceManager();
315 
316        Transaction tx = pm.currentTransaction();
317 
318        try
319        {
320            tx.begin();
321 
322            Extent extent = pm.getExtent( Project.class );
323 
324            Query query = pm.newQuery( extent );
325 
326            query.setResult( "projectGroup.id as projectGroupId, state as projectState, count(state) as size" );
327 
328            query.setResultClass( ProjectSummaryResult.class );
329 
330            query.setGrouping( "projectGroup.id, state" );
331 
332            List<ProjectSummaryResult> results = (List<ProjectSummaryResult>) query.execute();
333 
334            Map<Integer, ProjectGroupSummary> summaries = processProjectGroupSummary( results );
335 
336            tx.commit();
337 
338            return summaries;
339        }
340        finally
341        {
342            rollback( tx );
343        }
344    }
345 
346    private Map<Integer, ProjectGroupSummary> processProjectGroupSummary( List<ProjectSummaryResult> results )
347    {
348        Map<Integer, ProjectGroupSummary> map = new HashMap<Integer, ProjectGroupSummary>();
349 
350        for ( ProjectSummaryResult result : results )
351        {
352            ProjectGroupSummary summary;
353            int projectGroupId = result.getProjectGroupId();
354            int size = new Long( result.getSize() ).intValue();
355            int state = result.getProjectState();
356 
357            if ( map.containsKey( projectGroupId ) )
358            {
359                summary = map.get( projectGroupId );
360            }
361            else
362            {
363                summary = new ProjectGroupSummary( projectGroupId );
364            }
365 
366            summary.addProjects( size );
367 
368            if ( state == 2 )
369            {
370                summary.addNumberOfSuccesses( size );
371            }
372            else if ( state == 3 )
373            {
374                summary.addNumberOfFailures( size );
375            }
376            else if ( state == 4 )
377            {
378                summary.addNumberOfErrors( size );
379            }
380 
381            map.put( projectGroupId, summary );
382        }
383        return map;
384    }
385}

[all classes][org.apache.continuum.dao]
EMMA 2.0.5312 (C) Vladimir Roubtsov