java/com/google/gerrit/server/restapi/change/PostReviewCopyApprovalsOp.java - gerrit - Git at Google

 // Copyright (C) 2022 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.restapi.change;

 import static com.google.common.collect.ImmutableList.toImmutableList;

 import com.google.auto.factory.AutoFactory;
 import com.google.auto.factory.Provided;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableTable;
 import com.google.common.collect.Table.Cell;
 import com.google.gerrit.entities.Account;
 import com.google.gerrit.entities.LabelId;
 import com.google.gerrit.entities.PatchSet;
 import com.google.gerrit.entities.PatchSetApproval;
 import com.google.gerrit.server.PatchSetUtil;
 import com.google.gerrit.server.approval.ApprovalCopier;
 import com.google.gerrit.server.update.BatchUpdateOp;
 import com.google.gerrit.server.update.ChangeContext;
 import java.io.IOException;
 import java.util.Optional;

 /**
  * Batch update operation that copy approvals that have been newly applied on outdated patch sets to
  * the follow-up patch sets if they are copyable and no non-copied approvals prevent the copying.
  *
  * <p>Must be invoked after the batch update operation which applied new approvals on outdated patch
  * sets (e.g. after {@link PostReviewOp}.
  */
 @AutoFactory
 public class PostReviewCopyApprovalsOp implements BatchUpdateOp {
   private final ApprovalCopier approvalCopier;
   private final PatchSetUtil patchSetUtil;
   private final PatchSet.Id patchSetId;

   private ChangeContext ctx;
   private ImmutableList<PatchSet.Id> followUpPatchSets;

   PostReviewCopyApprovalsOp(
       @Provided ApprovalCopier approvalCopier,
       @Provided PatchSetUtil patchSetUtil,
       PatchSet.Id patchSetId) {
     this.approvalCopier = approvalCopier;
     this.patchSetUtil = patchSetUtil;
     this.patchSetId = patchSetId;
   }

   @Override
   public boolean updateChange(ChangeContext ctx) throws IOException {
     if (ctx.getNotes().getCurrentPatchSet().id().equals(patchSetId)) {
       // the updated patch set is the current patch, there a no follow-up patch set to which new
       // approvals could be copied
       return false;
     }

     init(ctx);

     boolean dirty = false;
     ImmutableTable<String, Account.Id, Optional<PatchSetApproval>> newApprovals =
         ctx.getUpdate(patchSetId).getApprovals();
     for (Cell<String, Account.Id, Optional<PatchSetApproval>> cell : newApprovals.cellSet()) {
       String label = cell.getRowKey();
       Account.Id approverId = cell.getColumnKey();
       PatchSetApproval.Key psaKey =
           PatchSetApproval.key(patchSetId, approverId, LabelId.create(label));

       if (isRemoval(cell)) {
         if (removeCopies(psaKey)) {
           dirty = true;
         }
         continue;
       }

       PatchSet patchSet = patchSetUtil.get(ctx.getNotes(), patchSetId);
       PatchSetApproval psaOrig = cell.getValue().get();

       // Target patch sets to which the approval is copyable.
       ImmutableList<PatchSet.Id> targetPatchSets =
           approvalCopier.forApproval(
               ctx.getNotes(),
               patchSet,
               psaKey.accountId(),
               psaKey.labelId().get(),
               psaOrig.value());

       // Iterate over all follow-up patch sets, in patch set order.
       for (PatchSet.Id followUpPatchSetId : followUpPatchSets) {
         if (hasOverrideOf(followUpPatchSetId, psaKey)) {
           // a non-copied approval exists that overrides any copied approval
           // -> do not copy the approval to this patch set nor to any follow-up patch sets
           break;
         }

         if (targetPatchSets.contains(followUpPatchSetId)) {
           // The approval is copyable to the new patch set.

           if (hasCopyOfWithValue(followUpPatchSetId, psaKey, psaOrig.value())) {
             // a copy approval with the exact value already exists
             continue;
           }

           // add/update the copied approval on the target patch set
           PatchSetApproval copiedPatchSetApproval = psaOrig.copyWithPatchSet(followUpPatchSetId);
           ctx.getUpdate(followUpPatchSetId).putCopiedApproval(copiedPatchSetApproval);
           dirty = true;
         } else {
           // The approval is not copyable to the new patch set.

           if (hasCopyOf(followUpPatchSetId, psaKey)) {
             // a copy approval exists and should be removed
             removeCopy(followUpPatchSetId, psaKey);
             dirty = true;
           }
         }
       }
     }

     return dirty;
   }

   private void init(ChangeContext ctx) {
     this.ctx = ctx;

     // compute follow-up patch sets (sorted by patch set ID)
     this.followUpPatchSets =
         ctx.getNotes().getPatchSets().keySet().stream()
             .filter(psId -> psId.get() > patchSetId.get())
             .collect(toImmutableList());
   }

   /**
    * Whether the given cell entry from the approval table represents the removal of an approval.
    *
    * @param cell cell entry from the approval table
    * @return {@code true} if the approval is not set or the approval has {@code 0} as the value,
    *     otherwise {@code false}
    */
   private boolean isRemoval(Cell<String, Account.Id, Optional<PatchSetApproval>> cell) {
     return cell.getValue().isEmpty() || cell.getValue().get().value() == 0;
   }

   /**
    * Removes copies of the given approval from all follow-up patch sets.
    *
    * @param psaKey the key of the patch set approval for which copies should be removed from all
    *     follow-up patch sets
    * @return whether any copy approval has been removed
    */
   private boolean removeCopies(PatchSetApproval.Key psaKey) {
     boolean dirty = false;
     for (PatchSet.Id followUpPatchSet : followUpPatchSets) {
       if (hasCopyOf(followUpPatchSet, psaKey)) {
         removeCopy(followUpPatchSet, psaKey);
       } else {
         // Do not remove copy from this follow-up patch sets and also not from any further follow-up
         // patch sets (if the further follow-up patch sets have copies they are copies of a
         // non-copied approval on this follow-up patch set and hence those should not be removed).
         break;
       }
     }
     return dirty;
   }

   /**
    * Removes the copy approval with the given key from the given patch set.
    *
    * @param patchSet patch set from which the copy approval with the given key should be removed
    * @param psaKey the key of the patch set approval for which copies should be removed from the
    *     given patch set
    */
   private void removeCopy(PatchSet.Id patchSet, PatchSetApproval.Key psaKey) {
     ctx.getUpdate(patchSet)
         .removeCopiedApprovalFor(
             ctx.getIdentifiedUser().getRealUser().isIdentifiedUser()
                 ? ctx.getIdentifiedUser().getRealUser().getAccountId()
                 : null,
             psaKey.accountId(),
             psaKey.labelId().get());
   }

   /**
    * Whether the given patch set has a copy approval with the given key.
    *
    * @param patchSetId the ID of the patch for which it should be checked whether it has a copy
    *     approval with the given key
    * @param psaKey the key of the patch set approval
    */
   private boolean hasCopyOf(PatchSet.Id patchSetId, PatchSetApproval.Key psaKey) {
     return ctx.getNotes().getApprovals().onlyCopied().get(patchSetId).stream()
         .anyMatch(psa -> areAccountAndLabelTheSame(psa.key(), psaKey));
   }

   /**
    * Whether the given patch set has a copy approval with the given key and value.
    *
    * @param patchSetId the ID of the patch for which it should be checked whether it has a copy
    *     approval with the given key and value
    * @param psaKey the key of the patch set approval
    */
   private boolean hasCopyOfWithValue(
       PatchSet.Id patchSetId, PatchSetApproval.Key psaKey, short value) {
     return ctx.getNotes().getApprovals().onlyCopied().get(patchSetId).stream()
         .anyMatch(psa -> areAccountAndLabelTheSame(psa.key(), psaKey) && psa.value() == value);
   }

   /**
    * Whether the given patch set has a normal approval with the given key that overrides copy
    * approvals with that key.
    *
    * @param patchSetId the ID of the patch for which it should be checked whether it has a normal
    *     approval with the given key that overrides copy approvals with that key
    * @param psaKey the key of the patch set approval
    */
   private boolean hasOverrideOf(PatchSet.Id patchSetId, PatchSetApproval.Key psaKey) {
     return ctx.getNotes().getApprovals().onlyNonCopied().get(patchSetId).stream()
         .anyMatch(psa -> areAccountAndLabelTheSame(psa.key(), psaKey));
   }

   private boolean areAccountAndLabelTheSame(
       PatchSetApproval.Key psaKey1, PatchSetApproval.Key psaKey2) {
     return psaKey1.accountId().equals(psaKey2.accountId())
         && psaKey1.labelId().equals(psaKey2.labelId());
   }
 }
	// Copyright (C) 2022 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.restapi.change;

	import static com.google.common.collect.ImmutableList.toImmutableList;

	import com.google.auto.factory.AutoFactory;
	import com.google.auto.factory.Provided;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableTable;
	import com.google.common.collect.Table.Cell;
	import com.google.gerrit.entities.Account;
	import com.google.gerrit.entities.LabelId;
	import com.google.gerrit.entities.PatchSet;
	import com.google.gerrit.entities.PatchSetApproval;
	import com.google.gerrit.server.PatchSetUtil;
	import com.google.gerrit.server.approval.ApprovalCopier;
	import com.google.gerrit.server.update.BatchUpdateOp;
	import com.google.gerrit.server.update.ChangeContext;
	import java.io.IOException;
	import java.util.Optional;

	/**
	* Batch update operation that copy approvals that have been newly applied on outdated patch sets to
	* the follow-up patch sets if they are copyable and no non-copied approvals prevent the copying.
	*
	* <p>Must be invoked after the batch update operation which applied new approvals on outdated patch
	* sets (e.g. after {@link PostReviewOp}.
	*/
	@AutoFactory
	public class PostReviewCopyApprovalsOp implements BatchUpdateOp {
	private final ApprovalCopier approvalCopier;
	private final PatchSetUtil patchSetUtil;
	private final PatchSet.Id patchSetId;

	private ChangeContext ctx;
	private ImmutableList<PatchSet.Id> followUpPatchSets;

	PostReviewCopyApprovalsOp(
	@Provided ApprovalCopier approvalCopier,
	@Provided PatchSetUtil patchSetUtil,
	PatchSet.Id patchSetId) {
	this.approvalCopier = approvalCopier;
	this.patchSetUtil = patchSetUtil;
	this.patchSetId = patchSetId;
	}

	@Override
	public boolean updateChange(ChangeContext ctx) throws IOException {
	if (ctx.getNotes().getCurrentPatchSet().id().equals(patchSetId)) {
	// the updated patch set is the current patch, there a no follow-up patch set to which new
	// approvals could be copied
	return false;
	}

	init(ctx);

	boolean dirty = false;
	ImmutableTable<String, Account.Id, Optional<PatchSetApproval>> newApprovals =
	ctx.getUpdate(patchSetId).getApprovals();
	for (Cell<String, Account.Id, Optional<PatchSetApproval>> cell : newApprovals.cellSet()) {
	String label = cell.getRowKey();
	Account.Id approverId = cell.getColumnKey();
	PatchSetApproval.Key psaKey =
	PatchSetApproval.key(patchSetId, approverId, LabelId.create(label));

	if (isRemoval(cell)) {
	if (removeCopies(psaKey)) {
	dirty = true;
	}
	continue;
	}

	PatchSet patchSet = patchSetUtil.get(ctx.getNotes(), patchSetId);
	PatchSetApproval psaOrig = cell.getValue().get();

	// Target patch sets to which the approval is copyable.
	ImmutableList<PatchSet.Id> targetPatchSets =
	approvalCopier.forApproval(
	ctx.getNotes(),
	patchSet,
	psaKey.accountId(),
	psaKey.labelId().get(),
	psaOrig.value());

	// Iterate over all follow-up patch sets, in patch set order.
	for (PatchSet.Id followUpPatchSetId : followUpPatchSets) {
	if (hasOverrideOf(followUpPatchSetId, psaKey)) {
	// a non-copied approval exists that overrides any copied approval
	// -> do not copy the approval to this patch set nor to any follow-up patch sets
	break;
	}

	if (targetPatchSets.contains(followUpPatchSetId)) {
	// The approval is copyable to the new patch set.

	if (hasCopyOfWithValue(followUpPatchSetId, psaKey, psaOrig.value())) {
	// a copy approval with the exact value already exists
	continue;
	}

	// add/update the copied approval on the target patch set
	PatchSetApproval copiedPatchSetApproval = psaOrig.copyWithPatchSet(followUpPatchSetId);
	ctx.getUpdate(followUpPatchSetId).putCopiedApproval(copiedPatchSetApproval);
	dirty = true;
	} else {
	// The approval is not copyable to the new patch set.

	if (hasCopyOf(followUpPatchSetId, psaKey)) {
	// a copy approval exists and should be removed
	removeCopy(followUpPatchSetId, psaKey);
	dirty = true;
	}
	}
	}
	}

	return dirty;
	}

	private void init(ChangeContext ctx) {
	this.ctx = ctx;

	// compute follow-up patch sets (sorted by patch set ID)
	this.followUpPatchSets =
	ctx.getNotes().getPatchSets().keySet().stream()
	.filter(psId -> psId.get() > patchSetId.get())
	.collect(toImmutableList());
	}

	/**
	* Whether the given cell entry from the approval table represents the removal of an approval.
	*
	* @param cell cell entry from the approval table
	* @return {@code true} if the approval is not set or the approval has {@code 0} as the value,
	* otherwise {@code false}
	*/
	private boolean isRemoval(Cell<String, Account.Id, Optional<PatchSetApproval>> cell) {
	return cell.getValue().isEmpty() \|\| cell.getValue().get().value() == 0;
	}

	/**
	* Removes copies of the given approval from all follow-up patch sets.
	*
	* @param psaKey the key of the patch set approval for which copies should be removed from all
	* follow-up patch sets
	* @return whether any copy approval has been removed
	*/
	private boolean removeCopies(PatchSetApproval.Key psaKey) {
	boolean dirty = false;
	for (PatchSet.Id followUpPatchSet : followUpPatchSets) {
	if (hasCopyOf(followUpPatchSet, psaKey)) {
	removeCopy(followUpPatchSet, psaKey);
	} else {
	// Do not remove copy from this follow-up patch sets and also not from any further follow-up
	// patch sets (if the further follow-up patch sets have copies they are copies of a
	// non-copied approval on this follow-up patch set and hence those should not be removed).
	break;
	}
	}
	return dirty;
	}

	/**
	* Removes the copy approval with the given key from the given patch set.
	*
	* @param patchSet patch set from which the copy approval with the given key should be removed
	* @param psaKey the key of the patch set approval for which copies should be removed from the
	* given patch set
	*/
	private void removeCopy(PatchSet.Id patchSet, PatchSetApproval.Key psaKey) {
	ctx.getUpdate(patchSet)
	.removeCopiedApprovalFor(
	ctx.getIdentifiedUser().getRealUser().isIdentifiedUser()
	? ctx.getIdentifiedUser().getRealUser().getAccountId()
	: null,
	psaKey.accountId(),
	psaKey.labelId().get());
	}

	/**
	* Whether the given patch set has a copy approval with the given key.
	*
	* @param patchSetId the ID of the patch for which it should be checked whether it has a copy
	* approval with the given key
	* @param psaKey the key of the patch set approval
	*/
	private boolean hasCopyOf(PatchSet.Id patchSetId, PatchSetApproval.Key psaKey) {
	return ctx.getNotes().getApprovals().onlyCopied().get(patchSetId).stream()
	.anyMatch(psa -> areAccountAndLabelTheSame(psa.key(), psaKey));
	}

	/**
	* Whether the given patch set has a copy approval with the given key and value.
	*
	* @param patchSetId the ID of the patch for which it should be checked whether it has a copy
	* approval with the given key and value
	* @param psaKey the key of the patch set approval
	*/
	private boolean hasCopyOfWithValue(
	PatchSet.Id patchSetId, PatchSetApproval.Key psaKey, short value) {
	return ctx.getNotes().getApprovals().onlyCopied().get(patchSetId).stream()
	.anyMatch(psa -> areAccountAndLabelTheSame(psa.key(), psaKey) && psa.value() == value);
	}

	/**
	* Whether the given patch set has a normal approval with the given key that overrides copy
	* approvals with that key.
	*
	* @param patchSetId the ID of the patch for which it should be checked whether it has a normal
	* approval with the given key that overrides copy approvals with that key
	* @param psaKey the key of the patch set approval
	*/
	private boolean hasOverrideOf(PatchSet.Id patchSetId, PatchSetApproval.Key psaKey) {
	return ctx.getNotes().getApprovals().onlyNonCopied().get(patchSetId).stream()
	.anyMatch(psa -> areAccountAndLabelTheSame(psa.key(), psaKey));
	}

	private boolean areAccountAndLabelTheSame(
	PatchSetApproval.Key psaKey1, PatchSetApproval.Key psaKey2) {
	return psaKey1.accountId().equals(psaKey2.accountId())
	&& psaKey1.labelId().equals(psaKey2.labelId());
	}
	}