private async Task <bool> CheckDisclaimerAsync(string clientId, string lykkeEntityId, DisclaimerType type)
        {
            IDisclaimer requiresApprovalDisclaimer = (await _redisService.GetDisclaimersAsync())
                                                     .Where(x => x.LykkeEntityId == lykkeEntityId)
                                                     .Where(o => o.Type == type)
                                                     .Where(o => o.StartDate < DateTime.UtcNow)
                                                     .OrderByDescending(p => p.StartDate)
                                                     .FirstOrDefault();

            if (requiresApprovalDisclaimer == null)
            {
                return(false);
            }

            IReadOnlyList <IClientDisclaimer> clientDisclaimers = await _redisService.GetClientDisclaimersAsync(clientId);

            HashSet <string> approvedDisclaimers = clientDisclaimers
                                                   .Where(o => o.Approved)
                                                   .Select(o => o.DisclaimerId)
                                                   .ToHashSet();

            List <Task> tasks;

            if (approvedDisclaimers.Contains(requiresApprovalDisclaimer.Id))
            {
                if (requiresApprovalDisclaimer.ShowOnEachAction)
                {
                    tasks = new List <Task>
                    {
                        _clientDisclaimerRepository.DeleteAsync(clientId, requiresApprovalDisclaimer.Id),
                        _redisService.DeleteClientDisclaimerAsync(clientId, requiresApprovalDisclaimer.Id)
                    };

                    await Task.WhenAll(tasks);
                }

                return(false);
            }

            var clientDisclaimer = new ClientDisclaimer
            {
                ClientId     = clientId,
                DisclaimerId = requiresApprovalDisclaimer.Id,
                ApprovedDate = DateTime.UtcNow
            };

            tasks = new List <Task>
            {
                _clientDisclaimerRepository.InsertOrReplaceAsync(clientDisclaimer),
                _redisService.AddClientDisclaimerAsync(clientDisclaimer)
            };

            await Task.WhenAll(tasks);

            _log.Info("Client pending disclaimer added", new  { clientId, requiresApprovalDisclaimer.Id });

            return(true);
        }
        public async Task DeleteAsync(string lykkeEntityId)
        {
            IReadOnlyList <IDisclaimer> disclaimers = (await _redisService.GetDisclaimersAsync())
                                                      .Where(x => x.LykkeEntityId == lykkeEntityId)
                                                      .ToList();

            if (disclaimers.Count > 0)
            {
                throw new InvalidOperationException("Can not delete Lykke entity if one or more disclaimers exists.");
            }

            var tasks = new List <Task>
            {
                _lykkeEntityRepository.DeleteAsync(lykkeEntityId),
                _redisService.DeleteLykkeEntityAsync(lykkeEntityId)
            };

            await Task.WhenAll(tasks);

            _log.Info("Lykke entity declined", new { lykkeEntityId });
        }
 public async Task <IReadOnlyList <IDisclaimer> > GetAsync(string lykkeEntityId)
 {
     return((await _redisService.GetDisclaimersAsync())
            .Where(x => x.LykkeEntityId == lykkeEntityId).ToList());
 }