| /******************************************************************************* | |
| * Copyright (c) 2010, 2012 Ericsson | |
| * | |
| * All rights reserved. This program and the accompanying materials are | |
| * made available under the terms of the Eclipse Public License v1.0 which | |
| * accompanies this distribution, and is available at | |
| * http://www.eclipse.org/legal/epl-v10.html | |
| * | |
| * Description: | |
| * | |
| * Contributors: | |
| * Alvaro Sanchez-Leon - Initial Implementation | |
| *******************************************************************************/ | |
| package org.eclipse.mylyn.reviews.r4e.core.model.serial.impl; | |
| import java.io.File; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.Date; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import org.eclipse.emf.common.util.EList; | |
| import org.eclipse.emf.common.util.EMap; | |
| import org.eclipse.emf.common.util.URI; | |
| import org.eclipse.emf.ecore.EObject; | |
| import org.eclipse.emf.ecore.resource.Resource; | |
| import org.eclipse.emf.ecore.resource.ResourceSet; | |
| import org.eclipse.mylyn.reviews.frame.core.model.SubModelRoot; | |
| import org.eclipse.mylyn.reviews.r4e.core.Activator; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EAnomaly; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EAnomalyTextPosition; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EAnomalyType; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EComment; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EContent; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EDelta; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EFileContext; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EFileVersion; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EFormalReview; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EID; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EIDComponent; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EItem; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EMeetingData; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EParticipant; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EReview; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EReviewGroup; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EReviewPhase; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EReviewPhaseInfo; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EReviewState; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EReviewType; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4ETextContent; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4ETextPosition; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EUser; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EUserReviews; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.R4EUserRole; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.RModelFactory; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.drules.DRModelFactory; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.drules.R4EDesignRule; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.drules.R4EDesignRuleArea; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.drules.R4EDesignRuleCollection; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.drules.R4EDesignRuleViolation; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.serial.IModelReader; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.serial.IModelWriter; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.serial.IRWUserBasedRes.ResourceType; | |
| import org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence; | |
| import org.eclipse.mylyn.reviews.r4e.core.rfs.ReviewsRFSProxy; | |
| import org.eclipse.mylyn.reviews.r4e.core.rfs.spi.ReviewsFileStorageException; | |
| import org.eclipse.mylyn.reviews.r4e.core.utils.ResourceUtils; | |
| import org.eclipse.mylyn.reviews.r4e.core.utils.VersionUtils; | |
| import org.eclipse.mylyn.reviews.r4e.core.utils.filePermission.UserPermission; | |
| /** | |
| * @author Alvaro Sanchez-Leon | |
| * | |
| */ | |
| public class RModelFactoryExtImpl implements Persistence.RModelFactoryExt { | |
| // ------------------------------------------------------------------------ | |
| // Fields | |
| // ------------------------------------------------------------------------ | |
| IModelWriter fWriter = SerializeFactory.getWriter(); | |
| IModelReader fReader = SerializeFactory.getReader(); | |
| // ------------------------------------------------------------------------ | |
| // GROUP Resource Methods | |
| // ------------------------------------------------------------------------ | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.GroupResFactory#createR4EReviewGroup(org.eclipse. | |
| * emf.common.util.URI, java.lang.String) | |
| */ | |
| public R4EReviewGroup createR4EReviewGroup(URI aFolderPath, String aGroupName) throws ResourceHandlingException { | |
| URI fileGroupURI = fWriter.createResourceURI(aGroupName, aFolderPath, ResourceType.GROUP); | |
| // create a new ResourceSet and resource for the given group | |
| Resource resource = fWriter.createResourceSetWithResource(fileGroupURI); | |
| R4EReviewGroup group = RModelFactory.eINSTANCE.createR4EReviewGroup(); | |
| // Set the revision level fragment and sub model version start at the same level | |
| group.setFragmentVersion(Roots.GROUP.getVersion()); | |
| resource.getContents().add(group); | |
| URI uri = group.eResource().getURI().trimSegments(1); | |
| // Update the resource | |
| group.setName(aGroupName); | |
| group.setFolder(URI.decode(uri.devicePath().toString())); | |
| fWriter.saveResource(resource); | |
| // Make sure a local review repository exist in this location | |
| File groupFolder = new File(URI.decode(aFolderPath.devicePath())); | |
| try { | |
| checkOrCreateRepo(groupFolder); | |
| } catch (ReviewsFileStorageException e) { | |
| throw new ResourceHandlingException(e); | |
| } | |
| return group; | |
| } | |
| /** | |
| * @param aFolderPath | |
| * @throws ReviewsFileStorageException | |
| */ | |
| private void checkOrCreateRepo(File aDir) throws ReviewsFileStorageException { | |
| boolean valid = ReviewsRFSProxy.isValidRepo(aDir); | |
| if (!valid) { | |
| // No valid review repository exist, time to create it | |
| ReviewsRFSProxy revRepo = new ReviewsRFSProxy(aDir, true); | |
| revRepo.close(); | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.GroupResFactory#openR4EReviewGroup(org.eclipse.emf | |
| * .common.util.URI) | |
| */ | |
| public R4EReviewGroup openR4EReviewGroup(URI aResourcePath) throws ResourceHandlingException, | |
| CompatibilityException { | |
| R4EReviewGroup group = fReader.deserializeTopElement(aResourcePath, R4EReviewGroup.class); | |
| // read group meta-data version from the loaded group | |
| String fragmentVersion = group.getFragmentVersion(); | |
| String appVersionLevel = Roots.GROUP.getVersion(); | |
| // validate if the group just opened is compatible with the current application | |
| validateCompatibility(Roots.GROUP, group.getName(), fragmentVersion, appVersionLevel, group); | |
| // Load resources from all participants | |
| URI folder = ResourceUtils.getFolderPath(aResourcePath); | |
| List<URI> usrGroupFiles = fReader.selectUsrReviewGroupRes(folder); | |
| try { | |
| for (URI uri : usrGroupFiles) { | |
| loadUsrReviews(group, uri); | |
| } | |
| } catch (ResourceHandlingException e) { | |
| // Attempt to close the group | |
| closeR4EReviewGroup(group); | |
| throw e; | |
| } | |
| // Build the mapping references to anomaly types | |
| EList<R4EAnomalyType> anomTypes = group.getAvailableAnomalyTypes(); | |
| for (Iterator<R4EAnomalyType> iterator = anomTypes.iterator(); iterator.hasNext();) { | |
| R4EAnomalyType r4eAnomalyType = iterator.next(); | |
| group.getAnomalyTypeKeyToReference().put(r4eAnomalyType.getType(), r4eAnomalyType); | |
| } | |
| URI resUri = group.eResource().getURI().trimSegments(1); | |
| // update the transient value of folder | |
| group.setFolder(URI.decode(resUri.devicePath().toString())); | |
| // Make sure a local review repository exist in this location | |
| File groupFolder = new File(URI.decode(folder.devicePath())); | |
| try { | |
| checkOrCreateRepo(groupFolder); | |
| } catch (ReviewsFileStorageException e) { | |
| // Attempt to close the group | |
| closeR4EReviewGroup(group); | |
| throw new ResourceHandlingException(e); | |
| } | |
| return group; | |
| } | |
| private void validateCompatibility(Roots aRoot, String aName, String aFragmentVersionInDisk, | |
| String appVersionLevel, SubModelRoot root) | |
| throws CompatibilityException { | |
| int compatibility = VersionUtils.compareVersions(appVersionLevel, aFragmentVersionInDisk); | |
| if (compatibility < 0) { | |
| // Not able to continue, not forward compatible | |
| // attempt to close what ever was opened from the element | |
| if (root instanceof R4EReviewGroup) { | |
| closeR4EReviewGroup((R4EReviewGroup) root); | |
| } else if (root instanceof R4EReview) { | |
| closeR4EReview((R4EReview) root); | |
| } else if (root instanceof R4EDesignRuleCollection) { | |
| closeR4EDesignRuleCollection((R4EDesignRuleCollection) root); | |
| } | |
| // Attempting to load a serialised model with a higher model version than the current one supported by the | |
| // application | |
| StringBuilder sb = new StringBuilder( | |
| "The " | |
| + aRoot.getName() | |
| + " \"" | |
| + aName | |
| + "\" is using a newer data format, please upgrade the application to the latest version"); | |
| sb.append("\n\"" + aName + "\" meta-data version: " + aFragmentVersionInDisk | |
| + ", Application meta-data version: " + appVersionLevel); | |
| throw new CompatibilityException(sb.toString()); | |
| } | |
| } | |
| /** | |
| * @param group | |
| * @param uri | |
| * @throws ResourceHandlingException | |
| */ | |
| private void loadUsrReviews(R4EReviewGroup group, URI uri) throws ResourceHandlingException { | |
| ResourceSet resSet = group.eResource().getResourceSet(); | |
| R4EUserReviews usrReviews = fReader.deserializeTopElement(uri, resSet, R4EUserReviews.class); | |
| if (usrReviews == null) { | |
| return; | |
| } | |
| // Associate the usrReviews to the group ResrourceSet | |
| associateToResourceSet(group, usrReviews); | |
| // keep reference to all userReviews within group | |
| group.getUserReviews().put(usrReviews.getName(), usrReviews); | |
| EList<String> reviewNames = usrReviews.getCreatedReviews(); | |
| // Add enabled reviews to overall review map | |
| for (String revName : reviewNames) { | |
| R4EReview review = usrReviews.getInvitedToMap().get(revName); | |
| if (review != null) { | |
| group.getReviewsMap().put(revName, review); | |
| group.getReviews().add(review); | |
| } | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.GroupResFactory#closeR4EReviewGroup(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EReviewGroup) | |
| */ | |
| public String closeR4EReviewGroup(R4EReviewGroup aReviewGroup) { | |
| StringBuilder sb = new StringBuilder(); | |
| // Obtain all resources | |
| Resource resource = aReviewGroup.eResource(); | |
| if (resource == null) { | |
| sb.append("Attempting to close a review group with no associated resource"); | |
| Activator.fTracer.traceDebug(sb.toString()); | |
| return sb.toString(); | |
| } | |
| ResourceSet resSet = resource.getResourceSet(); | |
| if (resSet == null) { | |
| sb.append("Attempting to close a review group with no associated resource set"); | |
| Activator.fTracer.traceDebug(sb.toString()); | |
| return sb.toString(); | |
| } | |
| EList<Resource> resList = resSet.getResources(); | |
| // unload then all | |
| for (Resource res : resList) { | |
| res.unload(); | |
| } | |
| return null; | |
| } | |
| // ------------------------------------------------------------------------ | |
| // REVIEW Resource Methods | |
| // ------------------------------------------------------------------------ | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.ReviewResFactory#createR4EReview(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EReviewGroup, java.lang.String, java.lang.String) | |
| */ | |
| public R4EReview createR4EReview(R4EReviewGroup aReviewGroup, String aReviewName, String aCreatedByUser) | |
| throws ResourceHandlingException { | |
| // validate | |
| if (aReviewGroup == null || aReviewName == null || aCreatedByUser == null) { | |
| return null; | |
| } | |
| R4EReview review = RModelFactory.eINSTANCE.createR4EReview(); | |
| reviewInit(aReviewGroup, aReviewName, aCreatedByUser, review); | |
| return review; | |
| } | |
| /** | |
| * @param aReviewGroup | |
| * @param aReviewName | |
| * @param aCreatedByUser | |
| * @param review | |
| * @throws ResourceHandlingException | |
| */ | |
| private void reviewInit(R4EReviewGroup aReviewGroup, String aReviewName, String aCreatedByUser, R4EReview review) | |
| throws ResourceHandlingException { | |
| // Initialize block | |
| Resource groupResource = createReviewInputCheck(aReviewGroup, aReviewName); | |
| ResourceSet resSet = groupResource.getResourceSet(); | |
| URI groupFilePath = groupResource.getURI(); | |
| groupFilePath = ResourceUtils.getFolderPath(groupFilePath); /* To directory */ | |
| // Set the revision level for the fragment and track the current one for the application | |
| review.setFragmentVersion(Roots.REVIEW.getVersion()); | |
| // Associate review to a resource | |
| review.setName(aReviewName); | |
| URI reviewURI = fWriter.createResourceURI(aReviewName, groupFilePath, ResourceType.REVIEW); | |
| Resource reviewResource = resSet.createResource(reviewURI); | |
| reviewResource.getContents().add(review); | |
| // UPDATE TRANSIENT REFERENCES WITH GROUP, USER GROUP, REVIEW AND PARTICIPANT | |
| aReviewGroup.getReviewsMap().put(aReviewName, review); | |
| aReviewGroup.getReviews().add(review); | |
| // CREATE PARTICIPANT resource and save it under the review folder | |
| // create the participant default roles | |
| List<R4EUserRole> role = new ArrayList<R4EUserRole>(); | |
| role.add(R4EUserRole.R4E_ROLE_ORGANIZER); | |
| role.add(R4EUserRole.R4E_ROLE_LEAD); | |
| R4EParticipant participant = (R4EParticipant) createR4EUser(review, aCreatedByUser, role, true); | |
| // Update pending associations to Review | |
| Date now = new Date(new Date().getTime()); | |
| R4EReviewState state = RModelFactory.eINSTANCE.createR4EReviewState(); | |
| state.setState(R4EReviewPhase.R4E_REVIEW_PHASE_STARTED); | |
| review.setCreatedBy(participant); | |
| review.setStartDate(now); | |
| review.getUsersMap().put(participant.getId(), participant); | |
| review.setState(state); | |
| review.setType(R4EReviewType.R4E_REVIEW_TYPE_BASIC); | |
| // SAVE REVIEW | |
| fWriter.saveResource(reviewResource); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.ReviewResFactory#createR4EFormalReview(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EReviewGroup, java.lang.String, java.lang.String) | |
| */ | |
| public R4EFormalReview createR4EFormalReview(R4EReviewGroup aReviewGroup, String aReviewName, String aCreatedByUser) | |
| throws ResourceHandlingException { | |
| // validate | |
| if (aReviewGroup == null || aReviewName == null || aCreatedByUser == null) { | |
| return null; | |
| } | |
| R4EFormalReview review = RModelFactory.eINSTANCE.createR4EFormalReview(); | |
| reviewInit(aReviewGroup, aReviewName, aCreatedByUser, review); | |
| return review; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.ReviewResFactory#createR4EReviewPhaseInfo(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EFormalReview) | |
| */ | |
| public R4EReviewPhaseInfo createR4EReviewPhaseInfo(R4EFormalReview aReview) throws ResourceHandlingException { | |
| // validate | |
| if (aReview == null) { | |
| return null; | |
| } | |
| R4EReviewPhaseInfo phase = RModelFactory.eINSTANCE.createR4EReviewPhaseInfo(); | |
| aReview.getPhases().add(phase); | |
| // Initial save of the new element | |
| aReview.eResource().getContents().add(phase); | |
| fWriter.saveResource(phase.eResource()); | |
| return phase; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.ReviewResFactory#createR4EMeetingData(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EReview) | |
| */ | |
| public R4EMeetingData createR4EMeetingData(R4EReview aReview) throws ResourceHandlingException { | |
| // validate | |
| if (aReview == null) { | |
| return null; | |
| } | |
| R4EMeetingData meetingd = RModelFactory.eINSTANCE.createR4EMeetingData(); | |
| aReview.setActiveMeeting(meetingd); | |
| // Initial save of the new element | |
| aReview.eResource().getContents().add(meetingd); | |
| fWriter.saveResource(meetingd.eResource()); | |
| return meetingd; | |
| } | |
| /** | |
| * @param aReviewGroup | |
| * @param aReviewName | |
| * @return | |
| * @throws ResourceHandlingException | |
| */ | |
| private Resource createReviewInputCheck(R4EReviewGroup aReviewGroup, String aReviewName) | |
| throws ResourceHandlingException { | |
| StringBuilder sb = new StringBuilder("ResourceSet not found in the review group provided"); | |
| // group resource | |
| Resource groupResource = aReviewGroup.eResource(); | |
| if (groupResource == null) { | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| sb.setLength(0); // clear | |
| sb.append("A review with this name already exists in Group: " + aReviewGroup.getName()); | |
| R4EReview review = aReviewGroup.getReviewsMap().get(aReviewName); | |
| if (review != null) { | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| return groupResource; | |
| } | |
| /** | |
| * @param review | |
| * @param participant | |
| * @return | |
| */ | |
| private Resource createUserReviewsResource(R4EReview review, R4EUser participant) { | |
| R4EReviewGroup aReviewGroup = (R4EReviewGroup) review.eContainer(); | |
| String aCreatedByUser = participant.getId(); | |
| ResourceSet resSet = review.eResource().getResourceSet(); | |
| URI groupFilePath = ResourceUtils.getFolderPath(aReviewGroup.eResource().getURI()); | |
| // CREATE USER GROUP RESOURCE if not already created | |
| R4EUserReviews uReviews = aReviewGroup.getUserReviews().get(participant.getId()); | |
| Resource ureviewsRes = null; | |
| if (uReviews == null) { | |
| uReviews = RModelFactory.eINSTANCE.createR4EUserReviews(); | |
| //create a user URI | |
| URI uri = defineParticipantResURI(aCreatedByUser, groupFilePath); | |
| ureviewsRes = resSet.createResource(uri); | |
| ureviewsRes.getContents().add(uReviews); | |
| uReviews.setName(participant.getId()); | |
| uReviews.setGroup(aReviewGroup); | |
| aReviewGroup.getUserReviews().put(participant.getId(), uReviews); | |
| } else { | |
| ureviewsRes = uReviews.eResource(); | |
| } | |
| uReviews.setGroup(aReviewGroup); | |
| EList<String> reviewList = uReviews.getCreatedReviews(); | |
| if (!(reviewList.contains(review.getName())) && participant.isReviewCreatedByMe()) { | |
| reviewList.add(review.getName()); | |
| } | |
| uReviews.getInvitedToMap().put(review.getName(), review); | |
| return ureviewsRes; | |
| } | |
| /** | |
| * Makes sure an existing resource file is not removed e.g. when having user | |
| * id's with different string case e.g. All capitals | |
| * | |
| * @param aCreatedByUser | |
| * @param groupFilePath | |
| * @return | |
| */ | |
| private URI defineParticipantResURI(String aCreatedByUser, URI groupFilePath) { | |
| String userSuffix = ""; | |
| URI uri = fWriter.createResourceURI(aCreatedByUser, groupFilePath, ResourceType.USER_GROUP); | |
| File file = new File(uri.devicePath()); | |
| int i = 0; | |
| while (file.exists()) { | |
| i++; | |
| userSuffix = Integer.toString(i); | |
| uri = fWriter.createResourceURI(aCreatedByUser + "_" + userSuffix, groupFilePath, ResourceType.USER_GROUP); | |
| file = new File(uri.devicePath()); | |
| } | |
| return uri; | |
| } | |
| public R4EReview openR4EReview(R4EReviewGroup aReviewGroup, String aReviewName) throws ResourceHandlingException, | |
| CompatibilityException { | |
| if (aReviewGroup == null) { | |
| return null; | |
| } | |
| // when the review is closed the element is marked as proxy and it's ready to be reloaded upon request. | |
| R4EReview review = aReviewGroup.getReviewsMap().get(aReviewName); | |
| if (review == null) { | |
| StringBuilder sb = new StringBuilder("Not able to find Review: " + aReviewName + "\tin group: " | |
| + aReviewGroup); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| boolean added = aReviewGroup.getReviews().add(review); | |
| if (added == false) { | |
| StringBuilder sb = new StringBuilder("The review was not added.. already present in parent group"); | |
| Activator.fTracer.traceDebug(sb.toString()); | |
| } | |
| // read review meta-data version from the loaded review | |
| String fragmentVersion = review.getFragmentVersion(); | |
| String appVersionLevel = Roots.REVIEW.getVersion(); | |
| // Validate compatibility of the review data just loaded against the current version level of the application | |
| validateCompatibility(Roots.REVIEW, review.getName(), fragmentVersion, appVersionLevel, review); | |
| URI folder = ResourceUtils.getFolderPath(review.eResource().getURI()); | |
| // Load resources from all participants | |
| List<URI> usrFiles = fReader.selectUsrCommentsRes(folder); | |
| try { | |
| for (URI uri : usrFiles) { | |
| loadUsrData(review, uri); | |
| } | |
| } catch (ResourceHandlingException e) { | |
| //try to close the partly opened review | |
| closeR4EReview(review); | |
| throw e; | |
| } | |
| return review; | |
| } | |
| private void associateToResourceSet(EObject base, EObject recent) { | |
| // Link the participant to the same ResourceSet as the review | |
| ResourceSet resSet = base.eResource().getResourceSet(); | |
| Resource resourcePresent = resSet.getResource(recent.eResource().getURI(), false); | |
| if (resourcePresent == null) { | |
| // Add the resource if not present | |
| resSet.getResources().add(recent.eResource()); | |
| } | |
| } | |
| /** | |
| * Loads the user itself and the related comments and Items to the review context | |
| * | |
| * @param review | |
| * @param uri | |
| * @throws ResourceHandlingException | |
| */ | |
| private void loadUsrData(R4EReview review, URI uri) throws ResourceHandlingException { | |
| ResourceSet resSet = review.eResource().getResourceSet(); | |
| R4EParticipant participant = fReader.deserializeTopElement(uri, resSet, R4EParticipant.class); | |
| if (participant == null) { | |
| return; | |
| } | |
| associateToResourceSet(review, participant); | |
| review.getUsersMap().put(participant.getId(), participant); | |
| // update refs to comments and particpant | |
| EList<R4EComment> comments = participant.getAddedComments(); | |
| if (comments != null) { | |
| for (R4EComment comment : comments) { | |
| review.getIdsMap().put(comment.getId(), comment); | |
| if (comment instanceof R4EAnomaly) { | |
| review.getTopics().add((R4EAnomaly) comment); | |
| } else { | |
| R4EAnomaly anomalyRef = comment.getAnomaly(); | |
| // Make sure it is associated to the same resource set | |
| associateToResourceSet(review, anomalyRef); | |
| anomalyRef.getComments().add(comment); | |
| } | |
| } | |
| } | |
| // update refs to items | |
| EList<R4EItem> items = participant.getAddedItems(); | |
| if (items != null && items.size() > 0) { | |
| R4EItem anItem = items.get(0); | |
| // associate item to resource set | |
| associateToResourceSet(review, anItem); | |
| // Get: Items | |
| for (R4EItem item : items) { | |
| EMap<R4EID, R4EIDComponent> idsMap = review.getIdsMap(); | |
| idsMap.put(item.getId(), item); | |
| review.getReviewItems().add(item); | |
| // Get: file contexts | |
| EList<R4EFileContext> fileCtxt = item.getFileContextList(); | |
| for (Iterator<R4EFileContext> iterator = fileCtxt.iterator(); iterator.hasNext();) { | |
| R4EFileContext r4eFileContext = iterator.next(); | |
| idsMap.put(r4eFileContext.getId(), r4eFileContext); | |
| // Get: Deltas | |
| EList<R4EDelta> deltas = r4eFileContext.getDeltas(); | |
| for (Iterator<R4EDelta> iterator2 = deltas.iterator(); iterator2.hasNext();) { | |
| R4EDelta delta = iterator2.next(); | |
| idsMap.put(delta.getId(), delta); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.ReviewResFactory#closeR4EReview(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EReview) | |
| */ | |
| public String closeR4EReview(R4EReview aReview) { | |
| // Get all participants | |
| Resource resource = null; | |
| Collection<R4EUser> participants = aReview.getUsersMap().values(); | |
| if (participants != null) { | |
| // Release resources associated to each participant | |
| for (Iterator<R4EUser> iterator = participants.iterator(); iterator.hasNext();) { | |
| R4EParticipant participant = (R4EParticipant) iterator.next(); | |
| resource = participant.eResource(); | |
| // participant + its comments | |
| if (resource != null) { | |
| resource.unload(); | |
| } | |
| EList<R4EItem> items = participant.getAddedItems(); | |
| if (items != null && items.size() > 0) { | |
| // items per participant | |
| for (Iterator<R4EItem> iterator2 = items.iterator(); iterator2.hasNext();) { | |
| R4EItem r4eItem = iterator2.next(); | |
| resource = r4eItem.eResource(); | |
| if (resource != null) { | |
| resource.unload(); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| R4EReviewGroup group = (R4EReviewGroup) aReview.eContainer(); | |
| if (group != null) { | |
| group.getReviews().remove(aReview); | |
| } else { | |
| StringBuilder sb = new StringBuilder("Closing a review where the parent group is null"); | |
| Activator.fTracer.traceError(sb.toString()); | |
| } | |
| // finally dispose the resource at the review level | |
| resource = aReview.eResource(); | |
| if (resource != null) { | |
| resource.unload(); | |
| } | |
| return null; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.ReviewResFactory#deleteR4EReview(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EReview, boolean) | |
| */ | |
| public String deleteR4EReview(R4EReview aReview, boolean aDeleteOnDisk) throws ResourceHandlingException { | |
| StringBuilder sb = new StringBuilder(); | |
| if (aReview == null) { | |
| sb.append("can not delete a null review"); | |
| return sb.toString(); | |
| } | |
| sb.setLength(0); | |
| Resource resource = aReview.eResource(); | |
| if (resource == null) { | |
| sb.append("No able to mark delete a review not associated to a resource"); | |
| return sb.toString(); | |
| } | |
| String reviewName = aReview.getName(); | |
| R4EReviewGroup group = (R4EReviewGroup) aReview.eContainer(); | |
| group.getReviewsMap().remove(reviewName); | |
| // // TODO: This action would require to update each user reviews file, where permissions may be an issue. For | |
| // the | |
| // // moment only mark the review as disabled and unload resources | |
| // EMap<String, R4EUserReviews> usrReviews = group.getUserReviews(); | |
| // if (usrReviews != null && usrReviews.size() > 0) { | |
| // Collection<R4EUserReviews> reviews = usrReviews.values(); | |
| // for (Iterator<R4EUserReviews> iterator = reviews.iterator(); iterator.hasNext();) { | |
| // R4EUserReviews r4eUserReviews = (R4EUserReviews) iterator.next(); | |
| // | |
| // // created list | |
| // EList<String> createdList = r4eUserReviews.getCreatedReviews(); | |
| // if (createdList != null && createdList.size() > 0) { | |
| // createdList.remove(reviewName); | |
| // } | |
| // | |
| // // invited list | |
| // r4eUserReviews.getInvitedToMap().remove(reviewName); | |
| // } | |
| // } | |
| // Update ReviewGroup | |
| group.getReviews().remove(aReview); | |
| // Mark the review as disabled | |
| aReview.setEnabled(false); | |
| // Save the status, this may cause | |
| fWriter.saveResource(resource); | |
| // unload resources | |
| closeR4EReview(aReview); | |
| return null; | |
| } | |
| // ------------------------------------------------------------------------ | |
| // ITEMS Resource Methods | |
| // ------------------------------------------------------------------------ | |
| /* | |
| * | |
| * /* (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4EItem(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EParticipant) | |
| */ | |
| public R4EItem createR4EItem(R4EParticipant aParticipant) throws ResourceHandlingException { | |
| if (aParticipant == null) { | |
| return null; | |
| } | |
| Resource usrResource = aParticipant.eResource(); | |
| if (usrResource == null) { | |
| StringBuilder sb = new StringBuilder("No resource found for given Participant: " + aParticipant.getId()); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| // Prepare before update | |
| R4EReview review = aParticipant.getReviewInstance(); | |
| R4EItem item = RModelFactory.eINSTANCE.createR4EItem(); | |
| R4EID itemID = RModelFactory.eINSTANCE.createR4EID(); | |
| itemID.setSequenceID(aParticipant.getSequenceIDCounterNext()); | |
| itemID.setUserID(aParticipant.getId()); | |
| ResourceSet resSet = usrResource.getResourceSet(); | |
| // update ITEM | |
| item.setAddedBy(aParticipant); | |
| item.setAddedById(aParticipant.getId()); | |
| item.setReview(review); | |
| item.setId(itemID); | |
| // update derived references to the review | |
| review.getIdsMap().put(itemID, item); | |
| review.getReviewItems().add(item); | |
| // Verify if an item already exists to append to the same resource | |
| int addedItems = aParticipant.getAddedItems().size(); | |
| Resource itemResource = null; | |
| if (addedItems > 0) { | |
| // Resolve items resource | |
| R4EItem firstItem = aParticipant.getAddedItems().get(0); | |
| itemResource = firstItem.eResource(); | |
| if (itemResource == null) { | |
| Activator.fTracer.traceError("Item found not associated to a Resource, addedBy: " | |
| + firstItem.getAddedById() + ", Description: " + firstItem.getDescription()); | |
| } | |
| } | |
| if (itemResource == null) { | |
| // crate item resource | |
| URI usrURI = usrResource.getURI(); | |
| URI reviewFolderURI = ResourceUtils.getFolderPath(usrURI); | |
| // create a uri for the new participant, the user is serialized within the comments resource | |
| URI itemURI = fWriter.createResourceURI(aParticipant.getId(), reviewFolderURI, ResourceType.USER_ITEM); | |
| // create a Resource for the Participant | |
| itemResource = resSet.createResource(itemURI); | |
| } | |
| // update Participant | |
| aParticipant.getAddedItems().add(item); | |
| // update resource | |
| itemResource.getContents().add(item); | |
| // Save persistence changes affecting the Participant and the actual items | |
| fWriter.saveResource(itemResource); | |
| fWriter.saveResource(usrResource); | |
| return item; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#deleteR4EItem(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EItem, boolean) | |
| */ | |
| public void deleteR4EItem(R4EItem aItem, boolean aDeleteOnDisk) throws ResourceHandlingException { | |
| if (aItem == null) { | |
| return; | |
| } | |
| R4EUser user = (R4EUser) aItem.eContainer(); | |
| if (user == null) { | |
| return; | |
| } | |
| // TODO: To consider before implementing actual resource removal | |
| // Removing other elements may have references to this item (e.g reviewed items) | |
| // Removing all references may present reading and writing conflicts and file permissions issues, since the | |
| // references may be across different users. | |
| // removing items may cause reshuffle of the references between items, and cause incorrect references indexes on | |
| // EMF | |
| // Disable the item itself | |
| aItem.setEnabled(false); | |
| // Disable all related deltas | |
| EList<R4EFileContext> fileContextList = aItem.getFileContextList(); | |
| if (fileContextList != null && fileContextList.size() > 0) { | |
| for (Iterator<R4EFileContext> iterator = fileContextList.iterator(); iterator.hasNext();) { | |
| R4EFileContext fileContext = iterator.next(); | |
| EList<R4EDelta> deltas = fileContext.getDeltas(); | |
| if (deltas != null && deltas.size() > 0) { | |
| for (Iterator<R4EDelta> iterator2 = deltas.iterator(); iterator2.hasNext();) { | |
| R4EDelta delta = iterator2.next(); | |
| delta.setEnabled(false); | |
| } | |
| } | |
| } | |
| } | |
| // Save the change of status | |
| Resource resource = aItem.eResource(); | |
| if (resource != null) { | |
| fWriter.saveResource(resource); | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4EFileContext(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EItem) | |
| */ | |
| public R4EFileContext createR4EFileContext(R4EItem item) throws ResourceHandlingException { | |
| R4EFileContext fileContext = null; | |
| if (!(isAssociatedToResource(item))) { | |
| StringBuilder sb = new StringBuilder("Can not create FileContext from an Item not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| fileContext = RModelFactory.eINSTANCE.createR4EFileContext(); | |
| item.getFileContextList().add(fileContext); | |
| Resource resource = item.eResource(); | |
| resource.getContents().add(fileContext); | |
| R4EUser user = (R4EUser) item.eContainer(); | |
| // Create an R4EID for the context | |
| R4EID contextID = RModelFactoryExt.eINSTANCE.createR4EID(); | |
| contextID.setSequenceID(user.getSequenceIDCounterNext()); | |
| contextID.setUserID(user.getId()); | |
| // Associate new fileContext with ID | |
| fileContext.setId(contextID); | |
| // Register ID to idMap at the review level | |
| user.getReviewInstance().getIdsMap().put(contextID, fileContext); | |
| fWriter.saveResource(resource); | |
| return fileContext; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4EBaseFileVersion(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EFileContext) | |
| */ | |
| public R4EFileVersion createR4EBaseFileVersion(R4EFileContext context) throws ResourceHandlingException { | |
| R4EFileVersion fileVersion = createR4EFileVersion(context); | |
| context.setBase(fileVersion); | |
| fWriter.saveResource(fileVersion.eResource()); | |
| return fileVersion; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4ETargetFileVersion(org | |
| * .eclipse.mylyn.reviews.r4e.core.model.R4EFileContext) | |
| */ | |
| public R4EFileVersion createR4ETargetFileVersion(R4EFileContext context) throws ResourceHandlingException { | |
| R4EFileVersion fileVersion = createR4EFileVersion(context); | |
| context.setTarget(fileVersion); | |
| fWriter.saveResource(fileVersion.eResource()); | |
| return fileVersion; | |
| } | |
| /** | |
| * @param context | |
| * @return | |
| * @throws ResourceHandlingException | |
| */ | |
| private R4EFileVersion createR4EFileVersion(R4EFileContext context) throws ResourceHandlingException { | |
| R4EFileVersion fileVersion = null; | |
| if (!(isAssociatedToResource(context))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create FileVersion from an context not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| fileVersion = RModelFactoryExt.eINSTANCE.createR4EFileVersion(); | |
| context.eResource().getContents().add(fileVersion); | |
| return fileVersion; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4EDelta(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EFileContext) | |
| */ | |
| public R4EDelta createR4EDelta(R4EFileContext context) throws ResourceHandlingException { | |
| R4EDelta delta = null; | |
| // Validate | |
| if (!(isAssociatedToResource(context))) { | |
| StringBuilder sb = new StringBuilder("Can not create Delta from a context not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| // input is expected to be fully created (all references updated) | |
| R4EItem item = (R4EItem) context.eContainer(); | |
| R4EUser user = (R4EUser) item.eContainer(); | |
| if (user == null) { | |
| return null; | |
| } | |
| // Create delta | |
| delta = RModelFactoryExt.eINSTANCE.createR4EDelta(); | |
| // Create an R4EID | |
| R4EID deltaID = RModelFactoryExt.eINSTANCE.createR4EID(); | |
| deltaID.setSequenceID(user.getSequenceIDCounterNext()); | |
| deltaID.setUserID(user.getId()); | |
| // Associate new delta to ID | |
| delta.setId(deltaID); | |
| // Register ID to idMap at the review level | |
| user.getReviewInstance().getIdsMap().put(deltaID, delta); | |
| // Associate delta to the context resource | |
| context.getDeltas().add(delta); | |
| // Save the resource | |
| context.eResource().getContents().add(delta); | |
| fWriter.saveResource(delta.eResource()); | |
| return delta; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#deleteR4EDelta(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.R4EDelta) | |
| */ | |
| public void deleteR4EDelta(R4EDelta delta) throws ResourceHandlingException { | |
| if (!(isAssociatedToResource(delta))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not udpate the State of a Delta if it's not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| delta.setEnabled(false); | |
| fWriter.saveResource(delta.eResource()); | |
| return; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4EBaseTextContent(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EDelta) | |
| */ | |
| public R4ETextContent createR4EBaseTextContent(R4EDelta delta) throws ResourceHandlingException { | |
| return createR4ETextContent(delta, true); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4ETargetTextContent(org | |
| * .eclipse.mylyn.reviews.r4e.core.model.R4EDelta) | |
| */ | |
| public R4ETextContent createR4ETargetTextContent(R4EDelta delta) throws ResourceHandlingException { | |
| return createR4ETextContent(delta, false); | |
| } | |
| /** | |
| * @param delta | |
| * @param base | |
| * @return | |
| * @throws ResourceHandlingException | |
| */ | |
| private R4ETextContent createR4ETextContent(R4EDelta delta, boolean base) throws ResourceHandlingException { | |
| if (!(isAssociatedToResource(delta))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create TextContent from a Delta/Selection not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| R4ETextContent txtContent = RModelFactoryExt.eINSTANCE.createR4ETextContent(); | |
| if (base) { | |
| delta.setBase(txtContent); | |
| } else { | |
| delta.setTarget(txtContent); | |
| } | |
| // Associate to Resource and save | |
| delta.eResource().getContents().add(txtContent); | |
| fWriter.saveResource(txtContent.eResource()); | |
| return txtContent; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserItemResFactory#createR4ETextPosition(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4ETextContent) | |
| */ | |
| public R4ETextPosition createR4ETextPosition(R4ETextContent content) throws ResourceHandlingException { | |
| R4ETextPosition textPosition = null; | |
| if (!(isAssociatedToResource(content))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create a TextLocation from a Content not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| textPosition = RModelFactoryExt.eINSTANCE.createR4ETextPosition(); | |
| content.setLocation(textPosition); | |
| // Associate to resource and save | |
| content.eResource().getContents().add(textPosition); | |
| fWriter.saveResource(textPosition.eResource()); | |
| return textPosition; | |
| } | |
| // ------------------------------------------------------------------------ | |
| // COMMENTS Resource Methods | |
| // ------------------------------------------------------------------------ | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#createR4EParticipant(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EReview, java.lang.String, java.util.List) | |
| */ | |
| public R4EParticipant createR4EParticipant(R4EReview aReview, String aParticipantId, List<R4EUserRole> aRoles) | |
| throws ResourceHandlingException { | |
| if (aRoles == null || aRoles.size() == 0) { | |
| StringBuilder sb = new StringBuilder("Creating a participant requires to define at least one role"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| return (R4EParticipant) createR4EUser(aReview, aParticipantId, aRoles, false); | |
| } | |
| /** | |
| * @param aReview | |
| * @param userId | |
| * @return | |
| * @throws ResourceHandlingException | |
| */ | |
| public R4EUser createR4EUser(R4EReview aReview, String userId) throws ResourceHandlingException { | |
| return createR4EUser(aReview, userId, null, false); | |
| } | |
| /** | |
| * @param aReview | |
| * @param aUserId | |
| * @param aRoles | |
| * @param newReview | |
| * - A new review is triggering the creation of this new user | |
| * @return | |
| * @throws ResourceHandlingException | |
| */ | |
| private R4EUser createR4EUser(R4EReview aReview, String aUserId, List<R4EUserRole> aRoles, boolean newReview) | |
| throws ResourceHandlingException { | |
| // Validate input | |
| if (aReview == null || aUserId == null) { | |
| return null; | |
| } | |
| R4EUser participant = aReview.getUsersMap().get(aUserId); | |
| StringBuilder sb = new StringBuilder(); | |
| if (participant != null) { | |
| // the participant is already present | |
| if (participant.eResource() == null) { | |
| sb.append("A participant with the same Id already exist in unknown state: " + aUserId); | |
| sb.append("/nClose and reopen review, to reset the state of the elements"); | |
| // participant exists but is not associated to a resource, e.g. unknown state of references | |
| throw new ResourceHandlingException(sb.toString()); | |
| } else { | |
| // user already exists | |
| // update roles (in case there are new ones) | |
| if (aRoles != null && participant instanceof R4EParticipant) { | |
| R4EParticipant dParticipant = (R4EParticipant) participant; | |
| EList<R4EUserRole> eRoles = dParticipant.getRoles(); | |
| for (Iterator<R4EUserRole> iterator = aRoles.iterator(); iterator.hasNext();) { | |
| R4EUserRole role = iterator.next(); | |
| if (!(eRoles.contains(role))) { | |
| eRoles.add(role); | |
| } | |
| } | |
| } | |
| // check if the user reviews lists are upto date | |
| Resource userReviewsRes = createUserReviewsResource(aReview, participant); | |
| fWriter.saveResource(userReviewsRes); | |
| return participant; | |
| } | |
| } | |
| sb.setLength(0); | |
| sb.append("ResourceSet not found to create participant: " + aUserId); | |
| // obtain ResourceSet from the Review | |
| Resource containerResource = aReview.eResource(); | |
| if (containerResource == null) { | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| ResourceSet resSet = containerResource.getResourceSet(); | |
| if (aRoles != null) { | |
| // create participant and build references | |
| participant = createR4EParticipantInstance(aReview, aUserId, aRoles); | |
| } else { | |
| participant = createR4EUserInstance(aReview, aUserId); | |
| } | |
| // A new review is triggering the creation of this participant | |
| if (newReview) { | |
| participant.setReviewCreatedByMe(true); | |
| } | |
| participant.getGroupPaths().add(containerResource.getURI().toString()); | |
| // find the review file uri to create the resource for the new participant | |
| URI folderPath = containerResource.getURI(); | |
| // convert to folder | |
| folderPath = ResourceUtils.getFolderPath(folderPath); | |
| // define the participants file URI | |
| URI participantURI = fWriter.createResourceURI(aUserId, folderPath, ResourceType.USER_COMMENT); | |
| // create a Resource for the Participant | |
| Resource participantResource = resSet.createResource(participantURI); | |
| // associate the participant with the resource | |
| participantResource.getContents().add(participant); | |
| // Serialize the participant resources | |
| Resource userReviewsRes = createUserReviewsResource(aReview, participant); | |
| fWriter.saveResource(participantResource); | |
| fWriter.saveResource(userReviewsRes); | |
| return participant; | |
| } | |
| /** | |
| * Create a brand new participant e.g. no associated comments | |
| * | |
| * @param aReview | |
| * @param aParticipantId | |
| * @param aRoles | |
| * @return | |
| */ | |
| private R4EParticipant createR4EParticipantInstance(R4EReview aReview, String aParticipantId, | |
| List<R4EUserRole> aRoles) { | |
| // participant and id | |
| R4EParticipant participant = RModelFactory.eINSTANCE.createR4EParticipant(); | |
| updateUsrReferences(participant, aParticipantId, aReview); | |
| // roles | |
| if (aRoles != null && aRoles.size() > 0) { | |
| for (Iterator<R4EUserRole> iterator = aRoles.iterator(); iterator.hasNext();) { | |
| R4EUserRole r4eUserRole = iterator.next(); | |
| participant.getRoles().add(r4eUserRole); | |
| } | |
| } | |
| return participant; | |
| } | |
| /** | |
| * Create a new R4E User | |
| * | |
| * @param aReview | |
| * @param aUserId | |
| * @return | |
| */ | |
| private R4EUser createR4EUserInstance(R4EReview aReview, String aUserId) { | |
| // participant and id | |
| R4EUser user = RModelFactory.eINSTANCE.createR4EUser(); | |
| updateUsrReferences(user, aUserId, aReview); | |
| return user; | |
| } | |
| private void updateUsrReferences(R4EUser aUser, String aUsrId, R4EReview aReview) { | |
| aUser.setId(aUsrId); | |
| aUser.setReviewInstance(aReview); | |
| // add to list of reviews | |
| if (aReview != null) { | |
| aReview.getUsersMap().put(aUsrId, aUser); | |
| } | |
| return; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#createR4EAnomaly(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EParticipant) | |
| */ | |
| public R4EAnomaly createR4EAnomaly(R4EParticipant aAnomalyCreator) throws ResourceHandlingException { | |
| // not able to obtain a unique id with an invalid participant or Review | |
| if (aAnomalyCreator == null) { | |
| return null; | |
| } | |
| R4EReview review = aAnomalyCreator.getReviewInstance(); | |
| R4EAnomaly anomaly = RModelFactory.eINSTANCE.createR4EAnomaly(); | |
| // set the transient eOpposite reference | |
| if (review != null) { | |
| review.getTopics().add(anomaly); | |
| } | |
| // Comments references | |
| updCommonCommentRefs(aAnomalyCreator, anomaly); | |
| // Save resources | |
| Resource participantRes = aAnomalyCreator.eResource(); | |
| participantRes.getContents().add(anomaly); | |
| fWriter.saveResource(participantRes); | |
| return anomaly; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#createR4EComment(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EParticipant, org.eclipse.mylyn.reviews.r4e.core.model.R4EAnomaly) | |
| */ | |
| public R4EComment createR4EComment(R4EParticipant aParticipant, R4EAnomaly aContainerAnomaly) | |
| throws ResourceHandlingException { | |
| if (aContainerAnomaly == null) { | |
| return null; | |
| } | |
| R4EComment comment = RModelFactory.eINSTANCE.createR4EComment(); | |
| aContainerAnomaly.getComments().add(comment); | |
| updCommonCommentRefs(aParticipant, comment); | |
| // Register the associated anomaly | |
| comment.setAnomaly(aContainerAnomaly); | |
| // Save resource, participant and anomalies go in the same resource | |
| Resource participantRes = aParticipant.eResource(); | |
| participantRes.getContents().add(comment); | |
| fWriter.saveResource(participantRes); | |
| return comment; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#createR4ETextContent(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EAnomaly) | |
| */ | |
| public R4ETextContent createR4ETextContent(R4EAnomaly anomaly) throws ResourceHandlingException { | |
| if (!(isAssociatedToResource(anomaly))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create TextContent from an Anomaly not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| R4ETextContent txtContent = RModelFactoryExt.eINSTANCE.createR4ETextContent(); | |
| anomaly.getLocation().add(txtContent); | |
| // Associate to Resource and save | |
| anomaly.eResource().getContents().add(txtContent); | |
| fWriter.saveResource(txtContent.eResource()); | |
| return txtContent; | |
| } | |
| public R4EAnomalyTextPosition createR4EAnomalyTextPosition(R4EContent content) throws ResourceHandlingException { | |
| R4EAnomalyTextPosition textPosition = null; | |
| if (!(isAssociatedToResource(content))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create an R4EAnomalyTextPosition from a Content not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| textPosition = RModelFactoryExt.eINSTANCE.createR4EAnomalyTextPosition(); | |
| content.setLocation(textPosition); | |
| // Associate to resource and save | |
| content.eResource().getContents().add(textPosition); | |
| fWriter.saveResource(textPosition.eResource()); | |
| return textPosition; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#createR4EFileVersion(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EAnomalyTextPosition) | |
| */ | |
| public R4EFileVersion createR4EFileVersion(R4EAnomalyTextPosition txtPosition) throws ResourceHandlingException { | |
| R4EFileVersion fileVersion = null; | |
| if (!(isAssociatedToResource(txtPosition))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create FileVersion from an txtPosition not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| fileVersion = RModelFactoryExt.eINSTANCE.createR4EFileVersion(); | |
| txtPosition.eResource().getContents().add(fileVersion); | |
| txtPosition.setFile(fileVersion); | |
| fWriter.saveResource(fileVersion.eResource()); | |
| return fileVersion; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#deleteR4EComment(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EComment, boolean) | |
| */ | |
| public void deleteR4EComment(R4EComment aComment, boolean aDeleteOnDisk) throws ResourceHandlingException { | |
| if (aComment == null) { | |
| return; | |
| } | |
| aComment.setEnabled(false); | |
| Resource resource = aComment.eResource(); | |
| if (resource == null) { | |
| StringBuilder sb = new StringBuilder("Not able to delete a comment with no associated resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| fWriter.saveResource(resource); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.UserCommentResFactory#deleteR4EAnomaly(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.R4EAnomaly, boolean) | |
| */ | |
| public void deleteR4EAnomaly(R4EAnomaly aAnomaly, boolean aDeleteOnDisk) throws ResourceHandlingException { | |
| deleteR4EComment(aAnomaly, aDeleteOnDisk); | |
| } | |
| /** | |
| * @param aCommentCreator | |
| * @param aComment | |
| */ | |
| private void updCommonCommentRefs(R4EParticipant aCommentCreator, R4EComment aComment) { | |
| Date createdOn = new Date(); | |
| aCommentCreator.getAddedComments().add(aComment); | |
| aComment.setUser(aCommentCreator); | |
| aComment.setCreatedOn(createdOn); | |
| // Assign the unique id to the comment | |
| R4EID id = RModelFactory.eINSTANCE.createR4EID(); | |
| id.setUserID(aCommentCreator.getId()); | |
| id.setSequenceID(aCommentCreator.getSequenceIDCounterNext()); | |
| aComment.setId(id); | |
| // update references from review | |
| aCommentCreator.getReviewInstance().getIdsMap().put(id, aComment); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence#testWritePermissions(org.eclipse.emf.common.util.URI) | |
| */ | |
| public boolean testWritePermissions(URI aLocation) throws ResourceHandlingException { | |
| if (aLocation == null) { | |
| StringBuilder sb = new StringBuilder("Illegal null argument recieved"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| String path = aLocation.toString(); | |
| File folder = new File(path); | |
| if ((!folder.isDirectory()) || (!folder.exists())) { | |
| StringBuilder sb = new StringBuilder("Illegal argument recieved i.e. URI is not a directory"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| // Perform actual write test | |
| return UserPermission.canWrite(path + File.separator + "test.txt"); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence#PollDirUpdates(org.eclipse.emf.ecore.EObject) | |
| */ | |
| public List<Resource> pollDirUpdates(EObject atElementLoc) { | |
| // TODO Implement me | |
| return null; | |
| } | |
| /** | |
| * @param eobject | |
| * @return | |
| */ | |
| private boolean isAssociatedToResource(EObject eobject) { | |
| if (eobject == null) { | |
| return false; | |
| } | |
| Resource resource = eobject.eResource(); | |
| if (resource == null) { | |
| return false; | |
| } | |
| // The associated resource is not null | |
| return true; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.DRulesFactory#createR4EDesignRuleCollection(org.eclipse | |
| * .emf.common.util.URI, java.lang.String) | |
| */ | |
| public R4EDesignRuleCollection createR4EDesignRuleCollection(URI aFolderPath, String aRuleCollectionName) | |
| throws ResourceHandlingException { | |
| URI fileGroupURI = fWriter.createResourceURI(aRuleCollectionName, aFolderPath, ResourceType.DRULE_SET); | |
| // create a new ResourceSet and resource for the given group | |
| Resource resource = fWriter.createResourceSetWithResource(fileGroupURI); | |
| R4EDesignRuleCollection ruleSet = DRModelFactory.eINSTANCE.createR4EDesignRuleCollection(); | |
| resource.getContents().add(ruleSet); | |
| // Set the revision level fragment and sub model version start at the same level | |
| ruleSet.setFragmentVersion(Roots.RULESET.getVersion()); | |
| // Update the resource | |
| ruleSet.setName(aRuleCollectionName); | |
| URI uri = ruleSet.eResource().getURI().trimSegments(1); | |
| ruleSet.setFolder(URI.decode(uri.devicePath().toString())); | |
| fWriter.saveResource(resource); | |
| return ruleSet; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.DRulesFactory#openR4EDesignRuleCollection(org.eclipse | |
| * .emf.common.util.URI) | |
| */ | |
| public R4EDesignRuleCollection openR4EDesignRuleCollection(URI aResourcePath) throws ResourceHandlingException, | |
| CompatibilityException { | |
| R4EDesignRuleCollection ruleSet = fReader.deserializeTopElement(aResourcePath, R4EDesignRuleCollection.class); | |
| URI resUri = ruleSet.eResource().getURI().trimSegments(1); | |
| // update the transient value of folder | |
| ruleSet.setFolder(URI.decode(resUri.devicePath().toString())); | |
| // read the rule set meta-data version just loaded | |
| String fragmentVersion = ruleSet.getFragmentVersion(); | |
| String appVersionLevel = Roots.RULESET.getVersion(); | |
| // Validate compatibility of the rule set data just loaded against the current version level of the application | |
| validateCompatibility(Roots.RULESET, ruleSet.getName(), fragmentVersion, appVersionLevel, ruleSet); | |
| return ruleSet; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.DRulesFactory#closeR4EDesignRuleCollection(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.drules.R4EDesignRuleCollection) | |
| */ | |
| public String closeR4EDesignRuleCollection(R4EDesignRuleCollection aDesRuleCollection) { | |
| // TODO: Make generic as closing a review group is currently fairly similar | |
| StringBuilder sb = new StringBuilder(); | |
| // Obtain all resources | |
| Resource resource = aDesRuleCollection.eResource(); | |
| if (resource == null) { | |
| sb.append("Attempting to close a design rule set with no associated resource"); | |
| Activator.fTracer.traceDebug(sb.toString()); | |
| return sb.toString(); | |
| } | |
| ResourceSet resSet = resource.getResourceSet(); | |
| if (resSet == null) { | |
| sb.append("Attempting to close a design rule set with no associated resource set"); | |
| Activator.fTracer.traceDebug(sb.toString()); | |
| return sb.toString(); | |
| } | |
| EList<Resource> resList = resSet.getResources(); | |
| for (Resource res : resList) { | |
| res.unload(); | |
| } | |
| return null; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.DRulesFactory#createR4EDesignRuleArea(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.drules.R4EDesignRuleCollection) | |
| */ | |
| public R4EDesignRuleArea createR4EDesignRuleArea(R4EDesignRuleCollection aRuleCollection) | |
| throws ResourceHandlingException { | |
| R4EDesignRuleArea darea = null; | |
| // Validate | |
| if (!(isAssociatedToResource(aRuleCollection))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create design rule area from a rule collection not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| // Create design rule area | |
| darea = DRModelFactory.eINSTANCE.createR4EDesignRuleArea(); | |
| // Associate the design rule area to the t resource | |
| aRuleCollection.getAreas().add(darea); | |
| aRuleCollection.eResource().getContents().add(darea); | |
| // Save the resource | |
| fWriter.saveResource(darea.eResource()); | |
| return darea; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.DRulesFactory#createR4EDesignRuleViolation(org.eclipse | |
| * .mylyn.reviews.r4e.core.model.drules.R4EDesignRuleArea) | |
| */ | |
| public R4EDesignRuleViolation createR4EDesignRuleViolation(R4EDesignRuleArea aRuleArea) | |
| throws ResourceHandlingException { | |
| R4EDesignRuleViolation drViolation = null; | |
| // Validate | |
| if (!(isAssociatedToResource(aRuleArea))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create design rule violation from a rule area not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| // Crate design rule violation | |
| drViolation = DRModelFactory.eINSTANCE.createR4EDesignRuleViolation(); | |
| // Associate the design rule violation to the context resource | |
| aRuleArea.getViolations().add(drViolation); | |
| // Save the resource | |
| aRuleArea.eResource().getContents().add(drViolation); | |
| fWriter.saveResource(drViolation.eResource()); | |
| return drViolation; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.mylyn.reviews.r4e.core.model.serial.Persistence.DRulesFactory#createR4EDesignRule(org.eclipse.mylyn | |
| * .reviews.r4e.core.model.drules.R4EDesignRuleViolation) | |
| */ | |
| public R4EDesignRule createR4EDesignRule(R4EDesignRuleViolation aViolation) throws ResourceHandlingException { | |
| R4EDesignRule dRule = null; | |
| // Validate | |
| if (!(isAssociatedToResource(aViolation))) { | |
| StringBuilder sb = new StringBuilder( | |
| "Can not create design rule from a container not associated to a Resource"); | |
| throw new ResourceHandlingException(sb.toString()); | |
| } | |
| // Crate design rule | |
| dRule = DRModelFactory.eINSTANCE.createR4EDesignRule(); | |
| // Associate the design rule to the context resource | |
| aViolation.getRules().add(dRule); | |
| // Save the resource | |
| aViolation.eResource().getContents().add(dRule); | |
| fWriter.saveResource(dRule.eResource()); | |
| return dRule; | |
| } | |
| public R4EReview copyR4EReview(URI origGroup, URI destGroup, String origReviewName, String destReviewName) { | |
| // Copier copier = new Copier(); | |
| return null; | |
| } | |
| } |