/// <summary>
        /// Checamos se estamos no momento de enviar e-mail:
        /// Aqui não importa EmailMarketingDelay, esse delay vai ser checado no Send
        /// e futuramente priorizado de acordo com remessas mais importantes
        /// e remessas que possam furar o delay.
        /// Checamos apenas se estamos no momento de envio da remessa ou por SendTime ou por Intervals
        /// </summary>
        /// <param name="user">Usuário que receberá o e-mail</param>
        /// <param name="cartDate">Data de abandono do carrinho</param>
        /// <param name="batchConfiguration">Configuração da remessa</param>
        /// <returns>Se podemos criar remessa agora para este usuário</returns>
        internal bool VerifyBatchCreationTime(UserVO user, DateTime cartDate, EmailBatchConfigurationVO batchConfiguration)
        {
            if (string.IsNullOrEmpty(batchConfiguration.SendIntervals))
            {
                if (batchConfiguration.SendTime.HasValue)
                {
                    return (DateTime.UtcNow - (user.LastEmailBatch ?? DateTime.MinValue))
                           > batchConfiguration.SendTime.Value;
                }
 
                throw new EventException(
                    "Remessa sem configuração de SendTime e SendInterval",
                    JsonSerializer.Serialize(batchConfiguration),
                    Configurations.Context.StoreId,
                    "Email");
            }
 
            var intervals = this.GetBatchIntervals(batchConfiguration);
 
            Debug.Assert(user.LastCartId != null, "user.LastCartId != null");
            var sentEmails = user.LastEmail == null ? 0 : Factory.AbandonedCartEmailCounterRepository().GetSentEmails(user.LastCartId.Value.ToString());
 
            if (sentEmails >= intervals.Count)
            {
                return false;
            }
 
            return (DateTime.UtcNow - cartDate).TotalHours > intervals[Convert.ToInt32(sentEmails)];
        }

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