// Copyright (C) 2009 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.gerrit.server.query.change;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.gerrit.reviewdb.client.Change;
import com.google.gerrit.reviewdb.client.ChangeMessage;
import com.google.gerrit.reviewdb.client.Patch;
import com.google.gerrit.reviewdb.client.PatchLineComment;
import com.google.gerrit.reviewdb.client.PatchSet;
import com.google.gerrit.reviewdb.client.PatchSet.Id;
import com.google.gerrit.reviewdb.client.PatchSetApproval;
import com.google.gerrit.reviewdb.client.Project;
import com.google.gerrit.reviewdb.client.TrackingId;
import com.google.gerrit.reviewdb.server.ReviewDb;
import com.google.gerrit.server.CurrentUser;
import com.google.gerrit.server.git.GitRepositoryManager;
import com.google.gerrit.server.patch.PatchList;
import com.google.gerrit.server.patch.PatchListCache;
import com.google.gerrit.server.patch.PatchListEntry;
import com.google.gerrit.server.patch.PatchListNotAvailableException;
import com.google.gerrit.server.project.ChangeControl;
import com.google.gwtorm.server.OrmException;
import com.google.gwtorm.server.ResultSet;
import com.google.inject.Provider;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ChangeData {
public static void ensureChangeLoaded(
Provider<ReviewDb> db, List<ChangeData> changes) throws OrmException {
Map<Change.Id, ChangeData> missing = Maps.newHashMap();
for (ChangeData cd : changes) {
if (cd.change == null) {
missing.put(cd.getId(), cd);
}
}
if (!missing.isEmpty()) {
for (Change change : db.get().changes().get(missing.keySet())) {
missing.get(change.getId()).change = change;
}
}
}
public static void ensureCurrentPatchSetLoaded(
Provider<ReviewDb> db, List<ChangeData> changes) throws OrmException {
Map<PatchSet.Id, ChangeData> missing = Maps.newHashMap();
for (ChangeData cd : changes) {
if (cd.currentPatchSet == null && cd.patches == null) {
missing.put(cd.change(db).currentPatchSetId(), cd);
}
}
if (!missing.isEmpty()) {
for (PatchSet ps : db.get().patchSets().get(missing.keySet())) {
ChangeData cd = missing.get(ps.getId());
cd.currentPatchSet = ps;
cd.patches = Lists.newArrayList(ps);
}
}
}
public static void ensureCurrentApprovalsLoaded(
Provider<ReviewDb> db, List<ChangeData> changes) throws OrmException {
List<ResultSet<PatchSetApproval>> pending = Lists.newArrayList();
for (ChangeData cd : changes) {
if (cd.currentApprovals == null && cd.approvals == null) {
pending.add(db.get().patchSetApprovals()
.byPatchSet(cd.change(db).currentPatchSetId()));
}
}
if (!pending.isEmpty()) {
int idx = 0;
for (ChangeData cd : changes) {
if (cd.currentApprovals == null && cd.approvals == null) {
cd.currentApprovals = pending.get(idx++).toList();
}
}
}
}
private final Change.Id legacyId;
private Change change;
private String commitMessage;
private PatchSet currentPatchSet;
private Collection<PatchSet> patches;
private Collection<PatchSetApproval> approvals;
private Map<PatchSet.Id,Collection<PatchSetApproval>> approvalsMap;
private Collection<PatchSetApproval> currentApprovals;
private String[] currentFiles;
private Collection<PatchLineComment> comments;
private Collection<TrackingId> trackingIds;
private CurrentUser visibleTo;
private ChangeControl changeControl;
private List<ChangeMessage> messages;
public ChangeData(final Change.Id id) {
legacyId = id;
}
public ChangeData(final Change c) {
legacyId = c.getId();
change = c;
}
public void setCurrentFilePaths(String[] filePaths) {
currentFiles = filePaths;
}
public String[] currentFilePaths(Provider<ReviewDb> db,
PatchListCache cache) throws OrmException {
if (currentFiles == null) {
Change c = change(db);
if (c == null) {
return null;
}
PatchSet ps = currentPatchSet(db);
if (ps == null) {
return null;
}
PatchList p;
try {
p = cache.get(c, ps);
} catch (PatchListNotAvailableException e) {
currentFiles = new String[0];
return currentFiles;
}
List<String> r = new ArrayList<String>(p.getPatches().size());
for (PatchListEntry e : p.getPatches()) {
if (Patch.COMMIT_MSG.equals(e.getNewName())) {
continue;
}
switch (e.getChangeType()) {
case ADDED:
case MODIFIED:
case DELETED:
case COPIED:
r.add(e.getNewName());
break;
case RENAMED:
r.add(e.getOldName());
r.add(e.getNewName());
break;
}
}
currentFiles = r.toArray(new String[r.size()]);
Arrays.sort(currentFiles);
}
return currentFiles;
}
public Change.Id getId() {
return legacyId;
}
public Change getChange() {
return change;
}
public boolean hasChange() {
return change != null;
}
boolean fastIsVisibleTo(CurrentUser user) {
return visibleTo == user;
}
ChangeControl changeControl() {
return changeControl;
}
void cacheVisibleTo(ChangeControl ctl) {
visibleTo = ctl.getCurrentUser();
changeControl = ctl;
}
public Change change(Provider<ReviewDb> db) throws OrmException {
if (change == null) {
change = db.get().changes().get(legacyId);
}
return change;
}
public PatchSet currentPatchSet(Provider<ReviewDb> db) throws OrmException {
if (currentPatchSet == null) {
Change c = change(db);
if (c == null) {
return null;
}
for (PatchSet p : patches(db)) {
if (p.getId().equals(c.currentPatchSetId())) {
currentPatchSet = p;
return p;
}
}
}
return currentPatchSet;
}
public Collection<PatchSetApproval> currentApprovals(Provider<ReviewDb> db)
throws OrmException {
if (currentApprovals == null) {
Change c = change(db);
if (c == null) {
currentApprovals = Collections.emptyList();
} else if (approvals != null) {
Map<Id, Collection<PatchSetApproval>> map = approvalsMap(db);
currentApprovals = map.get(c.currentPatchSetId());
if (currentApprovals == null) {
currentApprovals = Collections.emptyList();
map.put(c.currentPatchSetId(), currentApprovals);
}
} else {
currentApprovals = db.get().patchSetApprovals()
.byPatchSet(c.currentPatchSetId()).toList();
}
}
return currentApprovals;
}
public String commitMessage(GitRepositoryManager repoManager,
Provider<ReviewDb> db) throws IOException, OrmException {
if (commitMessage == null) {
PatchSet.Id psId = change(db).currentPatchSetId();
String sha1 = db.get().patchSets().get(psId).getRevision().get();
Project.NameKey name = change.getProject();
Repository repo = repoManager.openRepository(name);
try {
RevWalk walk = new RevWalk(repo);
try {
RevCommit c = walk.parseCommit(ObjectId.fromString(sha1));
commitMessage = c.getFullMessage();
} finally {
walk.release();
}
} finally {
repo.close();
}
}
return commitMessage;
}
public Collection<PatchSet> patches(Provider<ReviewDb> db)
throws OrmException {
if (patches == null) {
patches = db.get().patchSets().byChange(legacyId).toList();
}
return patches;
}
public Collection<PatchSetApproval> approvals(Provider<ReviewDb> db)
throws OrmException {
if (approvals == null) {
approvals = db.get().patchSetApprovals().byChange(legacyId).toList();
}
return approvals;
}
public Map<PatchSet.Id,Collection<PatchSetApproval>> approvalsMap(Provider<ReviewDb> db)
throws OrmException {
if (approvalsMap == null) {
Collection<PatchSetApproval> all = approvals(db);
approvalsMap = new HashMap<PatchSet.Id,Collection<PatchSetApproval>>(all.size());
for (PatchSetApproval psa : all) {
Collection<PatchSetApproval> c = approvalsMap.get(psa.getPatchSetId());
if (c == null) {
c = new ArrayList<PatchSetApproval>();
approvalsMap.put(psa.getPatchSetId(), c);
}
c.add(psa);
}
}
return approvalsMap;
}
public Collection<PatchLineComment> comments(Provider<ReviewDb> db)
throws OrmException {
if (comments == null) {
comments = db.get().patchComments().byChange(legacyId).toList();
}
return comments;
}
public Collection<TrackingId> trackingIds(Provider<ReviewDb> db)
throws OrmException {
if (trackingIds == null) {
trackingIds = db.get().trackingIds().byChange(legacyId).toList();
}
return trackingIds;
}
public List<ChangeMessage> messages(Provider<ReviewDb> db)
throws OrmException {
if (messages == null) {
messages = db.get().changeMessages().byChange(legacyId).toList();
}
return messages;
}
}