/// <summary>
        /// Prepare paged queued email list model
        /// </summary>
        /// <param name="searchModel">Queued email search model</param>
        /// <returns>Queued email list model</returns>
        public virtual QueuedEmailListModel PrepareQueuedEmailListModel(QueuedEmailSearchModel searchModel)
        {
            if (searchModel == null)
            {
                throw new ArgumentNullException(nameof(searchModel));
            }

            //get parameters to filter emails
            var startDateValue = !searchModel.SearchStartDate.HasValue ? null
                : (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.SearchStartDate.Value, _dateTimeHelper.CurrentTimeZone);
            var endDateValue = !searchModel.SearchEndDate.HasValue ? null
                : (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.SearchEndDate.Value, _dateTimeHelper.CurrentTimeZone).AddDays(1);

            //get queued emails
            var queuedEmails = _queuedEmailService.SearchEmails(fromEmail: searchModel.SearchFromEmail,
                                                                toEmail: searchModel.SearchToEmail,
                                                                createdFromUtc: startDateValue,
                                                                createdToUtc: endDateValue,
                                                                loadNotSentItemsOnly: searchModel.SearchLoadNotSent,
                                                                loadOnlyItemsToBeSent: false,
                                                                maxSendTries: searchModel.SearchMaxSentTries,
                                                                loadNewest: true,
                                                                pageIndex: searchModel.Page - 1, pageSize: searchModel.PageSize);

            //prepare list model
            var model = new QueuedEmailListModel
            {
                Data = queuedEmails.Select(queuedEmail =>
                {
                    //fill in model values from the entity
                    var queuedEmailModel = queuedEmail.ToModel <QueuedEmailModel>();

                    //little performance optimization: ensure that "Body" is not returned
                    queuedEmailModel.Body = string.Empty;

                    //convert dates to the user time
                    queuedEmailModel.CreatedOn = _dateTimeHelper.ConvertToUserTime(queuedEmail.CreatedOnUtc, DateTimeKind.Utc);

                    //fill in additional values (not existing in the entity)
                    //chai
                    //queuedEmailModel.PriorityName = queuedEmail.Priority.GetLocalizedEnum(_localizationService, _workContext);
                    queuedEmailModel.PriorityName = CommonHelper.ConvertEnum(queuedEmail.Priority.ToString());
                    if (queuedEmail.DontSendBeforeDateUtc.HasValue)
                    {
                        queuedEmailModel.DontSendBeforeDate = _dateTimeHelper
                                                              .ConvertToUserTime(queuedEmail.DontSendBeforeDateUtc.Value, DateTimeKind.Utc);
                    }

                    if (queuedEmail.SentOnUtc.HasValue)
                    {
                        queuedEmailModel.SentOn = _dateTimeHelper.ConvertToUserTime(queuedEmail.SentOnUtc.Value, DateTimeKind.Utc);
                    }

                    return(queuedEmailModel);
                }),
                Total = queuedEmails.TotalCount
            };

            return(model);
        }
示例#2
0
        public virtual IActionResult QueuedEmailList(QueuedEmailSearchModel searchModel)
        {
            //prepare model
            var model = _queuedEmailModelFactory.PrepareQueuedEmailListModel(searchModel);

            return(Json(model));
        }
示例#3
0
        public virtual IActionResult GoToEmailByNumber(QueuedEmailSearchModel model)
        {
            //try to get a queued email with the specified id
            var queuedEmail = _queuedEmailService.GetQueuedEmailById(model.GoDirectlyToNumber);

            if (queuedEmail == null)
            {
                return(List());
            }

            return(RedirectToAction("Edit", "QueuedEmail", new { id = queuedEmail.Id }));
        }
示例#4
0
        /// <returns>A task that represents the asynchronous operation</returns>
        public virtual async Task <IActionResult> QueuedEmailList(QueuedEmailSearchModel searchModel)
        {
            if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageMessageQueue))
            {
                return(await AccessDeniedDataTablesJson());
            }

            //prepare model
            var model = await _queuedEmailModelFactory.PrepareQueuedEmailListModelAsync(searchModel);

            return(Json(model));
        }
示例#5
0
        public virtual IActionResult QueuedEmailList(QueuedEmailSearchModel searchModel)
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageMessageQueue))
            {
                return(AccessDeniedKendoGridJson());
            }

            //prepare model
            var model = _queuedEmailModelFactory.PrepareQueuedEmailListModel(searchModel);

            return(Json(model));
        }
        /// <summary>
        /// Prepare queued email search model
        /// </summary>
        /// <param name="searchModel">Queued email search model</param>
        /// <returns>Queued email search model</returns>
        public virtual QueuedEmailSearchModel PrepareQueuedEmailSearchModel(QueuedEmailSearchModel searchModel)
        {
            if (searchModel == null)
            {
                throw new ArgumentNullException(nameof(searchModel));
            }

            //prepare default search values
            searchModel.SearchMaxSentTries = 10;

            //prepare page parameters
            searchModel.SetGridPageSize();

            return(searchModel);
        }
示例#7
0
        /// <summary>
        /// Prepare paged queued email list model
        /// </summary>
        /// <param name="searchModel">Queued email search model</param>
        /// <returns>Queued email list model</returns>
        public virtual QueuedEmailListModel PrepareQueuedEmailListModel(QueuedEmailSearchModel searchModel)
        {
            if (searchModel == null)
            {
                throw new ArgumentNullException(nameof(searchModel));
            }

            //get parameters to filter emails
            var startDateValue = searchModel.SearchStartDate?.ToUniversalTime();
            var endDateValue   = searchModel.SearchEndDate?.ToUniversalTime().AddDays(1);

            //get queued emails
            var queuedEmails = _queuedEmailService.SearchEmails(fromEmail: searchModel.SearchFromEmail,
                                                                toEmail: searchModel.SearchToEmail,
                                                                createdFromUtc: startDateValue,
                                                                createdToUtc: endDateValue,
                                                                loadNotSentItemsOnly: searchModel.SearchLoadNotSent,
                                                                maxSendTries: searchModel.SearchMaxSentTries,
                                                                pageIndex: searchModel.Page - 1, pageSize: searchModel.PageSize);

            //prepare list model
            var model = new QueuedEmailListModel().PrepareToGrid(searchModel, queuedEmails, () =>
            {
                return(queuedEmails.Select(queuedEmail =>
                {
                    //fill in model values from the entity
                    var queuedEmailModel = queuedEmail.ToModel <QueuedEmailModel>();

                    //little performance optimization: ensure that "Body" is not returned
                    queuedEmailModel.Body = string.Empty;

                    //convert dates to the user time
                    queuedEmailModel.CreatedOn = queuedEmail.CreatedOnUtc.ToLocalTime();

                    if (queuedEmail.SentOnUtc.HasValue)
                    {
                        queuedEmailModel.SentOn = queuedEmail.SentOnUtc.Value.ToLocalTime();
                    }

                    return queuedEmailModel;
                }));
            });

            return(model);
        }
        /// <summary>
        /// Prepare paged queued email list model
        /// </summary>
        /// <param name="searchModel">Queued email search model</param>
        /// <returns>
        /// A task that represents the asynchronous operation
        /// The task result contains the queued email list model
        /// </returns>
        public virtual async Task <QueuedEmailListModel> PrepareQueuedEmailListModelAsync(QueuedEmailSearchModel searchModel)
        {
            if (searchModel == null)
            {
                throw new ArgumentNullException(nameof(searchModel));
            }

            //get parameters to filter emails
            var startDateValue = !searchModel.SearchStartDate.HasValue ? null
                : (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.SearchStartDate.Value, await _dateTimeHelper.GetCurrentTimeZoneAsync());
            var endDateValue = !searchModel.SearchEndDate.HasValue ? null
                : (DateTime?)_dateTimeHelper.ConvertToUtcTime(searchModel.SearchEndDate.Value, await _dateTimeHelper.GetCurrentTimeZoneAsync()).AddDays(1);

            //get queued emails
            var queuedEmails = await _queuedEmailService.SearchEmailsAsync(fromEmail : searchModel.SearchFromEmail,
                                                                           toEmail : searchModel.SearchToEmail,
                                                                           createdFromUtc : startDateValue,
                                                                           createdToUtc : endDateValue,
                                                                           loadNotSentItemsOnly : searchModel.SearchLoadNotSent,
                                                                           loadOnlyItemsToBeSent : false,
                                                                           maxSendTries : searchModel.SearchMaxSentTries,
                                                                           loadNewest : true,
                                                                           pageIndex : searchModel.Page - 1, pageSize : searchModel.PageSize);

            //prepare list model
            var model = await new QueuedEmailListModel().PrepareToGridAsync(searchModel, queuedEmails, () =>
            {
                return(queuedEmails.SelectAwait(async queuedEmail =>
                {
                    //fill in model values from the entity
                    var queuedEmailModel = queuedEmail.ToModel <QueuedEmailModel>();

                    //little performance optimization: ensure that "Body" is not returned
                    queuedEmailModel.Body = string.Empty;

                    //convert dates to the user time
                    queuedEmailModel.CreatedOn = await _dateTimeHelper.ConvertToUserTimeAsync(queuedEmail.CreatedOnUtc, DateTimeKind.Utc);

                    //fill in additional values (not existing in the entity)
                    var emailAccount = await _emailAccountService.GetEmailAccountByIdAsync(queuedEmail.EmailAccountId);
                    queuedEmailModel.EmailAccountName = GetEmailAccountName(emailAccount);
                    queuedEmailModel.PriorityName = await _localizationService.GetLocalizedEnumAsync(queuedEmail.Priority);

                    if (queuedEmail.DontSendBeforeDateUtc.HasValue)
                    {
                        queuedEmailModel.DontSendBeforeDate = await _dateTimeHelper
                                                              .ConvertToUserTimeAsync(queuedEmail.DontSendBeforeDateUtc.Value, DateTimeKind.Utc);
                    }

                    if (queuedEmail.SentOnUtc.HasValue)
                    {
                        queuedEmailModel.SentOn = await _dateTimeHelper.ConvertToUserTimeAsync(queuedEmail.SentOnUtc.Value, DateTimeKind.Utc);
                    }

                    return queuedEmailModel;
                }));
            });

            return(model);
        }