Custom shopping cart check API plugin not working for Angular Shop 9.3.1 #509

Activity

1. gitpm

   added

   bugSomething isn't workingSomething isn't working

   on Jul 10, 2026
2. asattler commented on Jul 13, 2026

   

   asattler

   on Jul 13, 2026

   Last edited by asattler

   More actions

   Hi Peter,

   thanks for raising this. I didn't notice, even though my project is live with 9.3.1 for 6 months now...
   I was able to verify your issue and I also found a possible solution.
   The misunderstanding (or better: wrong or imcomplete example in the SDK) is that it's not clear that the ICartCheck.CheckAsync is called for each item in the cart. Which means that with example code:

   public Task<IReadOnlyList<ICartItemCheck>> CheckAsync(ICartItemCheckContext context, CancellationToken ct = default)
       {
           // Set up the individual ICartItemCheck object(s) and return them.
           _check = new SampleCheck(context);
           return Task.FromResult<IReadOnlyList<ICartItemCheck>>(new[]
           {
               _check
           });
       }
   

   you're always returning an array with one check to proceed, which seems to overwrite the previous collection.
   So instead of doing this, create a list and maintain it.

   So my proposed solution is (DO NOT USE THIS APPROACH, SEE MY LARTER POST):

   public class SampleCartCheck : ICartCheck
   {
       private List<SampleCheck> _checks = [];
   
       // This method is called when a shopping cart must be checked.
       public Task<IReadOnlyList<ICartItemCheck>> CheckAsync(ICartItemCheckContext context, CancellationToken ct = default)
       {
           // Set up the individual ICartItemCheck object(s) and return them.
           _checks.Add(new SampleCheck(context));
           return Task.FromResult<IReadOnlyList<ICartItemCheck>>(_checks);
           
       }
   
       public Task ProcessAsync(CancellationToken ct = default)
       {
           List<Task> tasks = [];
           foreach(var check in _checks)
           {
               tasks.Add(check.ProcessAsync(ct));
           }
           return Task.WhenAll([.. tasks]);
       }
   }
   

   I did a short test and it seems to work.
   Feel free to review and use :)

   BR

   Andreas
3. asattler commented on Jul 13, 2026

   

   asattler

   on Jul 13, 2026

   More actions

   My proposed solution doesn't seem to be the 100%. The web results now show multiple results per item...
   Seems like I need to invest a little more time. If you find a solution, please share with us @gitpm :)
4. asattler commented on Jul 14, 2026

   

   asattler

   on Jul 14, 2026

   Last edited by asattler

   More actions

   So, I re-checked my code and the behavior I can monitor.
   CheckAsync is called for every item, ProcessAsync is called once per cart.
   This lead me to the following assumption:

   public class SampleCartCheck : ICartCheck
   {
       private List<SampleCheck> _checks = [];
   
       // This method is called for each item in a shopping cart.
       public Task<IReadOnlyList<ICartItemCheck>> CheckAsync(ICartItemCheckContext context, CancellationToken ct = default)
       {
           // Set up the individual ICartItemCheck object(s) and return them.
           var singlecheck = new SampleCheck(context);
           _checks.Add(singlecheck);
           return Task.FromResult<IReadOnlyList<ICartItemCheck>>([singlecheck]);
           
       }
   
       // this method is called once per cart to run the checks;
       public async Task ProcessAsync(CancellationToken ct = default)
       {
           foreach(var check in _checks)
           {
               await check.ProcessAsync(ct).ConfigureAwait(false);
           }
       }
   }
   

   I did a short test, and it seems to work as expected.
5. gitpm commented on Jul 14, 2026

   

   gitpm

   on Jul 14, 2026

   Author

   More actions

   Hi Andreas,

   Thanks a lot for sharing your solution.

   It looks straightforward, and you're right. In my opinion, it makes perfect sense to create a separate ICartItemCheck for each ShoppingCartItem.

   I just created a simple cross-check test, and it seems to work in my project as well.

   Nevertheless, I noticed that the empty constructor of the ICartItemCheck class is still being invoked for some unknown reason. But as long as the result is correct, I don't really care why it happens.

   
6. petermuehlhoefer commented on Aug 3, 2026

   

   petermuehlhoefer

   on Aug 3, 2026

   Last edited by petermuehlhoefer

   More actions

   Finally I solved the problem with this implementation:

   Models and Interfaces

   First of all I extended the ICartItemCheck by a ProcessCheckAsync-Methode in order to set the ICartItemCheck -Attributes within the instance of the ICartItemCheck-Interface-class.

   public interface ICccCartItemCheckHandler : ICartItemCheck
       {
           Task<CccCartItemCheckResult> ProcessCheckAsync(CancellationToken ct = default);
       }
    public sealed record CccCartItemCheckResult(
           CheckStatus Status,
           string? ResultText = null,
           object? Detail = null);
   }
   

   CartCheckProvider

   public class CccCartCheckProvider : ICartCheckProvider, IKnownTypeProvider
       {
           public Task<IReadOnlyList<ICartCheck>> GetCartChecksAsync(ICartCheckContext cart,
               CancellationToken ct = default)
           {
               return Task.FromResult<IReadOnlyList<ICartCheck>>
                   (
                     [new  CccCartCheck()]
                   );
           }
   
           // Konkreter ICartItemCheck-Typ muss bekannt sein, da Ergebnisse als JSON gespeichert werden  
           public IReadOnlyDictionary<Type, IReadOnlyList<Type>> GetTypes()
           {
               return new Dictionary<Type, IReadOnlyList<Type>>
               {
                   { typeof(ICartItemCheck),
                     [typeof(DuplicateShoppingCartItemInBasketCartItemCheck),  // example 1 of an ICartItemCheck (ICccCartItemCheckHandler)
                       typeof(DuplicateOrderCartItemCheck)] // example 2 of an ICartItemCheck (ICccCartItemCheckHandler)
                   }
               };
           }
       }
   

   CartCheck

   Then it goes straight forward:

       public class CccCartCheck : ICartCheck
       {
           private List<ICccCartItemCheckHandler> _cartItemChecks = new List<ICccCartItemCheckHandler>();
   
           public Task<IReadOnlyList<ICartItemCheck>> CheckAsync(ICartItemCheckContext context,
               CancellationToken ct = default)
           {
               List<ICccCartItemCheckHandler> multipleChecksOfTheShoppingCartItem = ShoppingCartItemCheckFactory.CreateShoppingCartItemChecks(context, ct);
   
               // Set up the individual ICartItemCheck object(s) and return them.
               _cartItemChecks.AddRange(multipleChecksOfTheShoppingCartItem);
               return Task.FromResult<IReadOnlyList<ICartItemCheck>>(multipleChecksOfTheShoppingCartItem);
   
           }
   
           public async Task ProcessAsync(CancellationToken ct = default)
           {
   
   #if DEBUG
               foreach (ICccCartItemCheckHandler cartItemCheck in _cartItemChecks)
               {
                   var cartItemCheckResult = await cartItemCheck.ProcessCheckAsync(ct);
               }
   #else
              await Task.WhenAll(_cartItemChecks.Select(check => check.ProcessCheckAsync(ct)));
   #endif
           }
       }
       }
   

   Example of an ICccCartItemCheckHandler provided by the ShoppingCartItemCheckFactory

       internal abstract class CccCartItemCheckBase: ICccCartItemCheckHandler
       {
           protected readonly ICartItemCheckContext _context;
   
           // Kopfdaten der Prüfung, die in der Ergebnisliste angezeigt werden.
           public abstract string Id { get; }
           public abstract string Title { get; }
   
   
           // Prüfergebnis der Prüfung, das in der Ergebnisliste angezeigt wird.
           public CheckStatus Status { get; set; } = CheckStatus.Pending;
           public string ResultText { get; set; }
           // Populate this property to append any serializable data to the result.
           public object Detail { get; set; }
   
   
           public CccCartItemCheckBase() { }
   
           public CccCartItemCheckBase(ICartItemCheckContext context)
           {
               _context = context;
           }
   
           public abstract Task<CccCartItemCheckResult> ProcessCheckAsync(CancellationToken ct = default);
   
           protected void SetResult(CccCartItemCheckResult result)
           {
               Status = result.Status;
               ResultText = result.ResultText;
               Detail = result.Detail;
           }
       }
   
       internal class DuplicateOrderCartItemCheck : CccCartItemCheckBase
       {
           // Kopfdaten der Prüfung, die in der Ergebnisliste angezeigt werden.
           public override string Id => "DuplicateOrderCartItemCheck";
           public override string Title => "Prüfe, ob eine identische Bestellung im Warensystem vorliegt.";
   
   
           public DuplicateOrderCartItemCheck() : base()
           {
           }
   
           public DuplicateOrderCartItemCheck(ICartItemCheckContext context) : base(context)
           { }
   
   
           public override async Task<CccCartItemCheckResult> ProcessCheckAsync(CancellationToken ct = default)
           {
               // Prüfe ob eine Bestellung mit den gleichen Parametern bereits existiert
               CccCartItemCheckResult duplicateOrderExists = await OrderCheckHandler.CheckIfOrderWithSameParametersAlreadyExists(_context, ct);
               var result = duplicateOrderExists ?? new CccCartItemCheckResult(CheckStatus.Success, "Keine identische Bestellung gefunden.");
               SetResult(result);
               return result;
        
   

   👍React with 👍1Reacted by Niels de Groot
7. github-actions commented on Sep 2, 2026

   

   github-actionsBot

   on Sep 2, 2026 – with GitHub Actions

   More actions

   This issue has not seen any action for a while! Closing for now, but it can be reopened at a later date.
8. github-actions

   added

   no-issue-activity

   on Sep 2, 2026
9. github-actions

   closed this as not plannedon Sep 9, 2026