feat: filter canceled transactions in a group

back-end/apps/chain/src/execute/execute.service.spec.ts

@@ -576,5 +576,62 @@ describe('ExecuteService', () => {
         `Transaction Group cannot be submitted. Error validating transaction 0: ${errorMessage}`,
       );
     });
+
+    it('should execute all transactions except the canceled', async () => {
+      const { receipt, response } = mockSDKTransactionExecution();
+
+      transactionGroup.groupItems[0].transaction.status = TransactionStatus.CANCELED;
+
+      transactionGroupRepo.findOne.mockResolvedValueOnce(transactionGroup);
+      transactionRepo.findOne.mockResolvedValue({
+        status: TransactionStatus.WAITING_FOR_EXECUTION,
+      } as Transaction);
+
+      await service.executeTransactionGroup(transactionGroup);
+
+      expect(response.getReceipt).toHaveBeenCalled();
+
+      transactionGroup.groupItems.forEach(groupItem => {
+        if (groupItem.transaction.status === TransactionStatus.CANCELED) {
+          expect(transactionRepo.update).not.toHaveBeenCalledWith(
+            { id: groupItem.transaction.id },
+            expect.anything(),
+          );
+        } else {
+          expect(transactionRepo.update).toHaveBeenCalledWith(
+            { id: groupItem.transaction.id },
+            {
+              executedAt: expect.any(Date),
+              status: TransactionStatus.EXECUTED,
+              statusCode: receipt.status._code,
+            },
+          );
+        }
+      });
+
+      expect(client.close).toHaveBeenCalled();
+    });
+
+    it('should not execute any transactions if all transactions are canceled', async () => {
+      transactionGroup.groupItems.forEach(groupItem => {
+        groupItem.transaction.status = TransactionStatus.CANCELED;
+      });
+
+      transactionGroupRepo.findOne.mockResolvedValueOnce(transactionGroup);
+      transactionRepo.findOne.mockResolvedValue({
+        status: TransactionStatus.WAITING_FOR_EXECUTION,
+      } as Transaction);
+
+      const result = await service.executeTransactionGroup(transactionGroup);
+
+      expect(result.transactions).toEqual([]);
+
+      transactionGroup.groupItems.forEach(groupItem => {
+        expect(transactionRepo.update).not.toHaveBeenCalledWith(
+          { id: groupItem.transaction.id },
+          expect.anything(),
+        );
+      });
+    });
   });
 });

back-end/apps/chain/src/execute/execute.service.ts

@@ -48,10 +48,19 @@ export class ExecuteService {
 
   @MurLock(15000, 'transactionGroup.id + "_group"')
   async executeTransactionGroup(transactionGroup: ExecuteTransactionGroupDto) {
+    const filteredTransactionGroup: ExecuteTransactionGroupDto = {
+      ...transactionGroup,
+      groupItems: transactionGroup.groupItems.filter(
+        tx =>
+          tx.transaction.status !== TransactionStatus.CANCELED &&
+          tx.transaction.status !== TransactionStatus.EXPIRED &&
+          tx.transaction.status !== TransactionStatus.WAITING_FOR_SIGNATURES,
+      ),
+    };
     const transactions: { sdkTransaction: SDKTransaction; transaction: ExecuteTransactionDto }[] =
       [];
     // first we need to validate all the transactions, as they all need to be valid before we can execute any of them
-    for (const groupItemDto of transactionGroup.groupItems) {
+    for (const groupItemDto of filteredTransactionGroup.groupItems) {
       const transaction = groupItemDto.transaction;
       try {
         const sdkTransaction = await this.getValidatedSDKTransaction(transaction);

front-end/src/renderer/pages/TransactionDetails/components/TransactionDetailsHeader.vue

@@ -140,10 +140,6 @@ const isCreator = computed(() => {
   return creator.value.user.id === user.selectedOrganization.userId;
 });
 
-const isAdmin = computed(() => {
-  return user.selectedOrganization.role === 'admin';
-});
-
 const transactionIsInProgress = computed(
   () =>
     props.organizationTransaction &&
@@ -187,16 +183,12 @@ const canRemind = computed(() => {
     isCreator.value &&
     transactionIsInProgress.value
   );
-})
+});
 
 const canArchive = computed(() => {
   const isManual = props.organizationTransaction?.isManual;
 
-  return (
-    isManual &&
-    isCreator.value &&
-    transactionIsInProgress.value
-  );
+  return isManual && isCreator.value && transactionIsInProgress.value;
 });
 
 const visibleButtons = computed(() => {