private static MailMessage CreateMailMessage(EmailMessage emailMessage, IEmailSettings emailSettings)
        {
            var mailMessage = new MailMessage
            {
                Subject     = emailMessage.Subject,
                Body        = emailMessage.Message,
                ReplyToList = { emailSettings.FromEmailAddress },
                From        = new MailAddress(emailSettings.FromEmailAddress)
            };

            SetAddresses(emailMessage.ToAddresses, mailMessage.To);
            SetAddresses(emailMessage.CcAddresses, mailMessage.CC);
            SetAddresses(emailMessage.BccAddresses, mailMessage.Bcc);
            var tempPath = Path.GetTempPath();

            foreach (var attachedItem in emailMessage.AttachedItems)
            {
                var fileContent = attachedItem.Content as IFileContent;
                if (fileContent == null)
                {
                    continue;//TODO - add error
                }
                var attachedFileInfo = fileContent.SaveToFile(tempPath);
                if (attachedFileInfo != null)
                {
                    mailMessage.Attachments.Add(new Attachment(attachedFileInfo.FullName));
                }
            }
            return(mailMessage);
        }
Esempio n. 2
0
        /// <summary>
        /// Configure the emailer - note that if config isn't valid this sill silently fail
        /// </summary>
        /// <param name="eSettings">Settings to use to configure error emailing</param>
        public static void Setup(IEmailSettings eSettings)
        {
            if (!eSettings.ToAddress.HasValue())
            {
                Trace.WriteLine("Configuration invalid: ToAddress must have a value");
                return; // not enabled
            }

            ToAddress = eSettings.ToAddress;
            if (eSettings.FromAddress.HasValue())
            {
                FromAddress = eSettings.FromDisplayName.HasValue()
                                  ? new MailAddress(eSettings.FromAddress, eSettings.FromDisplayName)
                                  : new MailAddress(eSettings.FromAddress);
            }

            if (eSettings.SMTPUserName.HasValue() && eSettings.SMTPPassword.HasValue())
            {
                Credentials = new NetworkCredential(eSettings.SMTPUserName, eSettings.SMTPPassword);
            }

            if (eSettings.SMTPHost.HasValue())
            {
                Host = eSettings.SMTPHost;
            }
            if (eSettings.SMTPPort != 25)
            {
                Port = eSettings.SMTPPort;
            }
            EnableSSL = eSettings.SMTPEnableSSL;

            PreventDuplicates = eSettings.PreventDuplicates;
            Enabled           = true;
        }
        /// <summary>
        /// Configure the emailer - note that if config isn't valid this sill silently fail
        /// </summary>
        /// <param name="eSettings">Settings to use to configure error emailing</param>
        public static void Setup(IEmailSettings eSettings)
        {
            if (!eSettings.ToAddress.HasValue())
            {
                Trace.WriteLine("Configuration invalid: ToAddress must have a value");
                return; // not enabled
            }

            ToAddress = eSettings.ToAddress;
            if (eSettings.FromAddress.HasValue())
            {
                FromAddress = eSettings.FromDisplayName.HasValue()
                                  ? new MailAddress(eSettings.FromAddress, eSettings.FromDisplayName)
                                  : new MailAddress(eSettings.FromAddress);
            }

            if (eSettings.SMTPUserName.HasValue() && eSettings.SMTPPassword.HasValue())
                Credentials = new NetworkCredential(eSettings.SMTPUserName, eSettings.SMTPPassword);

            if (eSettings.SMTPHost.HasValue()) Host = eSettings.SMTPHost;
            if (eSettings.SMTPPort != 25) Port = eSettings.SMTPPort;
            EnableSSL = eSettings.SMTPEnableSSL;

            PreventDuplicates = eSettings.PreventDuplicates;
            Enabled = true;
            
        }
 public AdminNotificationService(IEmailSettings emailSettings,
                                 IService <Database.Models.User> userService,
                                 IService <Organization> organizationService) : base(emailSettings)
 {
     _userService         = userService;
     _organizationService = organizationService;
 }
Esempio n. 5
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EmailSendRealizer"/> class.
 /// </summary>
 /// <param name="settings">Reference to class Settings. Refers to the data of the Settings class.</param>
 /// <param name="emailSender">>Reference to the class Sender. Refers the SendEmailAsync() method. Uses async/await.</param>
 /// <param name="watcher"> Reference to the WatcherWrapper class. The wraper of FileSystemWatcher class.</param>
 /// <param name="file">Reference to the FileWrapper class. The wrapper of File's parent class FileInfo.</param>
 public EmailSendRealizer(IEmailSettings settings, ISender emailSender, IWatcher watcher, IFileWrapper file)
 {
     this._settings    = settings;
     this._emailSender = emailSender;
     this._watcher     = watcher;
     this._file        = file;
 }
Esempio n. 6
0
        /// <summary>
        ///   Create instance of EmailService with specified providers
        /// </summary>
        /// <param name="mailProvider"></param>
        /// <param name="templateProvider"></param>
        /// <param name="emailTemplateConfiguration"></param>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="EmailSettingsException"></exception>
        public EmailService(IMailProvider mailProvider, IMessageTemplateProvider templateProvider,
                            IEmailTemplateConfiguration emailTemplateConfiguration)
        {
            _log = LogManager.GetLogger(GetType());

            if (mailProvider == null)
            {
                throw new ArgumentNullException(nameof(mailProvider));
            }
            if (emailTemplateConfiguration == null)
            {
                throw new ArgumentNullException(nameof(emailTemplateConfiguration));
            }
            _emailSettings = new Settings().EmailSettings;

            if (_emailSettings == null)
            {
                throw new EmailSettingsException();
            }

            _mailProvider               = mailProvider;
            _templateProvider           = templateProvider;
            _emailTemplateConfiguration = emailTemplateConfiguration;
            _engineService              = RazorEngineService.Create((ITemplateServiceConfiguration)_emailTemplateConfiguration);
        }
Esempio n. 7
0
 public ShedulerService(IEmailService emailService, IFormMessageService formMessageService, IEmailSettings emailSettings, IMessage message, ISiteSettings siteSettings)
 {
     _emailService       = emailService;
     _formMessageService = formMessageService;
     _emailSettings      = emailSettings;
     _siteSettings       = siteSettings;
     _message            = message;
 }
Esempio n. 8
0
 public ShareAdminTests()
 {
     _emailSettings = new EmailSettings
     {
         LocalDirectoryPath = "C:\\temp",
         Sender             = "*****@*****.**",
         Subject            = "Hey see my questions!"
     };
 }
Esempio n. 9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EmailSender"/> class.
 /// </summary>
 /// <param name="unitOfWork">Unit of work.</param>
 /// <param name="eventAggregator">Event aggregator.</param>
 /// <param name="resourceHandler">Resource handler.</param>
 /// <param name="settings">E-mail settings.</param>
 public EmailSender(
     IUnitOfWork unitOfWork,
     IEventAggregator eventAggregator,
     IResourceHandler resourceHandler,
     IEmailSettings settings)
 {
     this.unitOfWork      = unitOfWork;
     this.eventAggregator = eventAggregator;
     this.resourceHandler = resourceHandler;
     this.settings        = settings;
 }
Esempio n. 10
0
            public async Task Execute(IJobExecutionContext context)
            {
                JobDataMap dataMap = context.JobDetail.JobDataMap;

                _emailService       = (IEmailService)dataMap["emailService"];
                _formMessageService = (IFormMessageService)dataMap["formMessageService"];
                _emailSettings      = (IEmailSettings)dataMap["emailSettings"];
                _message            = (IMessage)dataMap["message"];
                _siteSettings       = (ISiteSettings)dataMap["siteSettings"];
                await _emailService.SendEmailAsync(_formMessageService, _emailSettings, _message, _siteSettings);
            }
Esempio n. 11
0
 public EmailNotificationService(IEmailSettings emailSettings,
                                 IAdminNotificationService adminNotificationService,
                                 IUserNotificationService userNotificationService,
                                 ILegalOfficerNotificationService legalOfficerNotificationService,
                                 IConsumerProviderRegistrationNotificatonService consumerProviderRegistrationNotificationService)
     : base(emailSettings)
 {
     Admin        = adminNotificationService;
     User         = userNotificationService;
     LegalOfficer = legalOfficerNotificationService;
     ConsumerProviderRegistration = consumerProviderRegistrationNotificationService;
 }
Esempio n. 12
0
 public Sender(IEmailSettings emailSettings)
 {
     this._emailSettings = emailSettings;
     this._client        = new SmtpClient(this._emailSettings.Host);
     this._mailMessage   =
         new MailMessage(this._emailSettings.FromAddress, this._emailSettings.ToAddress)
     {
         BodyEncoding = Encoding.UTF8,
         Subject      = this._emailSettings.Subject,
         Body         = this._emailSettings.MailBody
     };
 }
Esempio n. 13
0
 public static void BootstrapForTests(
     ISystemLog systemLog,
     IOfficeLocationDatabaseSettings officeLocationDatabaseSettings,
     ICountryWebApiSettings countryWebApiSettings,
     IEmailSettings emailSettings,
     IGroupNameConstants groupNameConstants)
 {
     BootstrapAll(systemLog,
                  officeLocationDatabaseSettings,
                  countryWebApiSettings,
                  emailSettings,
                  groupNameConstants);
 }
Esempio n. 14
0
 public UserNotificationService(IService <Database.Models.User> userService,
                                IService <LicenseClauseTemplate> clausesTemplateService,
                                IService <OrganizationLicense> licenseService,
                                IService <Application> appService,
                                IService <Organization> organizationService,
                                IService <DataSchema> dataSchemaService,
                                IEmailSettings emailSettings) : base(emailSettings)
 {
     _userService            = userService;
     _clausesTemplateService = clausesTemplateService;
     _licenseService         = licenseService;
     _appService             = appService;
     _organizationService    = organizationService;
     _dataSchemaService      = dataSchemaService;
 }
Esempio n. 15
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EmailService"/> class.
 /// </summary>
 public EmailService()
 {
     _config = new EmailServiceSettings();
     this._config.AuthenticationPassword = ConfigurationSettings.AppSettings["SMTPAuthenticationPassword"].ToString();
     this._config.AuthenticationUserName = ConfigurationSettings.AppSettings["SMTPAuthenticationUserName"].ToString();
     this._config.SmptServer = ConfigurationSettings.AppSettings["SmtpServer"].ToString();
     this._config.Port = Convert.ToInt16(ConfigurationSettings.AppSettings["SmtpPort"]);
     this._config.EnableSSL = ConfigurationSettings.AppSettings["EnableSSL"].ToString();
     this._config.UseDefaultCredentials = ConfigurationSettings.AppSettings["UseDefaultCredentials"].ToString();
     if (ConfigurationSettings.AppSettings["SmtpPort"].ToString() == "")
     {
         this._config.UsePort = false;
     }
     this._config.IsAuthenticationRequired = true;
 }
Esempio n. 16
0
        private static void BootstrapAll(
            ISystemLog logForNetSystemLog,
            IOfficeLocationDatabaseSettings officeLocationDatabaseSettings,
            ICountryWebApiSettings countryWebApiSettings,
            IEmailSettings emailSettings,
            IGroupNameConstants groupNameConstants)
        {
            var webServiceCaller = new WebApiServiceCaller(logForNetSystemLog);

            MasterFactory.OfficeDataTableGateway =
                new OfficeDataTableGateway(officeLocationDatabaseSettings, logForNetSystemLog);
            MasterFactory.CountryWebApiGateway =
                new CountryWebApiGateway(countryWebApiSettings, webServiceCaller);
            MasterFactory.EmailClient        = new EmailClient(emailSettings);
            MasterFactory.GroupNameConstants = groupNameConstants;
        }
Esempio n. 17
0
        public BaseEmailService(IEmailSettings emailSettings)
        {
            _emailSettings = emailSettings;
            var viewEngines = new ViewEngineCollection();
            var viewsPath   = Path.Combine(ConfigurationManager.AppSettings["PathToEmailViews"]);

            viewEngines.Add(new FileRazorViewEngine(viewsPath));
            _emailService  = new EmailService(viewEngines, BuildSmtpClient);
            _emailDumpPath = $"{AppDomain.CurrentDomain.BaseDirectory}{emailSettings.PathToMail}";
            Directory.CreateDirectory(_emailDumpPath);
            // todo : move all configuration to a ninject
            // todo: move to config
            DataLinkerHost         = ConfigurationManager.AppSettings["DataLinkerHost"];
            UrlToCssFile           = ConfigurationManager.AppSettings["UrlToCSSEmail"];
            UrlForImageInEmail     = ConfigurationManager.AppSettings["UrlToImageInEmail"];
            DataLinkerContactEmail = ConfigurationManager.AppSettings["DataLinkerContactEmail"];
        }
Esempio n. 18
0
        public static void BootstrapForSystem(
            string logName,
            IOfficeLocationDatabaseSettings officeLocationDatabaseSettings,
            ICountryWebApiSettings countryWebApiSettings,
            IEmailSettings emailSettings,
            IGroupNameConstants groupNameConstants)
        {
            LoggingBootstrapper.StartupLog(logName);

            var logForNetSystemLog = new LogForNetSystemLog();

            BootstrapAll(logForNetSystemLog,
                         officeLocationDatabaseSettings,
                         countryWebApiSettings,
                         emailSettings,
                         groupNameConstants);
        }
Esempio n. 19
0
        internal static EmailItems ToEmailItems(IEmailSettings settings, EmailType type, IEnumerable <string> to, IEnumerable <string> cc, string subject, string content)
        {
            var email = new EmailItems
            {
                // "From" comes directly from settings (no validation)
                FromName  = settings.FromName,
                FromEmail = settings.FromEmail,

                // "To" is possibly set by the "Type" (or by what was passed in)
                To = (type switch
                {
                    EmailType.Exception => settings.ExceptionsRecipients,
                    EmailType.HiddenException => settings.HiddenExceptionRecipients,
                    EmailType.Logging => settings.LoggingRecipients,
                    EmailType.LongRunning => settings.LongRunningRecipients,
                    EmailType.HttpFailure => settings.HttpFailureRecipients,
                    EmailType.Custom => to,
                    _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
                }).ToList()
Esempio n. 20
0
        /// <summary>
        ///   Create instance of EmailService with specified providers
        /// </summary>
        /// <param name="logger"></param>
        /// <param name="configuration"></param>
        /// <param name="mailProvider"></param>
        /// <param name="templateProvider"></param>
        /// <param name="emailTemplateConfiguration"></param>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="EmailSettingsException"></exception>
        public EmailService(ILogger <EmailService> logger, IConfiguration configuration, IMailProvider mailProvider,
                            IMessageTemplateProvider templateProvider, IEmailTemplateConfiguration emailTemplateConfiguration, IMessageProvider messageProvider)
        {
            _logger        = logger;
            _configuration = configuration;

            var section = _configuration.GetSection("gaia:emailSettings");

            //if (section?.Value == null)
            //{
            //	throw new EmailSettingsException();
            //}

            _emailSettings = new EmailSettings();
            section.Bind(_emailSettings);

            _mailProvider               = mailProvider ?? throw new ArgumentNullException(nameof(mailProvider));
            _templateProvider           = templateProvider ?? throw new ArgumentNullException(nameof(templateProvider));
            _emailTemplateConfiguration = emailTemplateConfiguration ?? throw new ArgumentNullException(nameof(emailTemplateConfiguration));
            _messageProvider            = messageProvider ?? throw new ArgumentNullException(nameof(messageProvider));
        }
Esempio n. 21
0
 public ConsumerProviderRegistrationNotificationService(IEmailSettings emailSettings,
                                                        IService <OrganizationLicense> licenseService,
                                                        IService <Application> applicationService,
                                                        IService <Organization> organizationService,
                                                        IService <LicenseTemplate> licenseTemplateService,
                                                        ILicenseContentBuilder licenseContentBuilder,
                                                        IService <Database.Models.User> userService,
                                                        IService <LicenseAgreement> agreementService,
                                                        IService <ConsumerProviderRegistration, int> consumerProviderRegistration,
                                                        IService <DataSchema> dataSchemaService,
                                                        ILicenseFileProvider licenseFileProvider) : base(emailSettings)
 {
     _licenseService                = licenseService;
     _applicationService            = applicationService;
     _organizationService           = organizationService;
     _licenseTemplateService        = licenseTemplateService;
     _licenseContentBuilder         = licenseContentBuilder;
     _userService                   = userService;
     _agreementService              = agreementService;
     _consumerProviderRegistrations = consumerProviderRegistration;
     _dataSchemaService             = dataSchemaService;
     _licenseFileProvider           = licenseFileProvider;
 }
Esempio n. 22
0
        public async Task SendEmailAsync(IFormMessageService formMessageService, IEmailSettings emailSettings, IMessage message, ISiteSettings siteSettings)
        {
            var emailMessage = new MimeMessage();

            emailMessage.From.Add(new MailboxAddress(message.SenderName, message.SenderEmail));
            emailMessage.To.Add(new MailboxAddress("", message.RecieverEmail));
            emailMessage.Subject = message.MessageSubject;
            emailMessage.Body    = new TextPart(MimeKit.Text.TextFormat.Html)
            {
                Text = message.MessageBody + Environment.NewLine + formMessageService.GetMessage(siteSettings)
            };

            using (var client = new SmtpClient())
            {
                await client.ConnectAsync(emailSettings.Host, emailSettings.Port, emailSettings.EnableSSL);

                await client.AuthenticateAsync(emailSettings.UserEmail, emailSettings.UserPassword);

                await client.SendAsync(emailMessage);

                await client.DisconnectAsync(true);
            }
        }
Esempio n. 23
0
 public EmailTarget(IEmailSettings settings)
 {
     _settings = settings;
 }
Esempio n. 24
0
 /// <summary>
 /// Initialize the configuration.
 /// </summary>
 /// <param name="config"></param>
 public void Init(IEmailSettings config)
 {
     _config = config;
 }
Esempio n. 25
0
 public EmailClient(IEmailSettings emailSettings) => _emailSettings = emailSettings;
Esempio n. 26
0
 public MimeKitEmailSender(ISmtpSettings settings, IEmailSettings emailSettings)
 {
     _settings      = settings;
     _emailSettings = emailSettings;
 }
 public WecEmailClient(IEmailSettings settings)
 {
     _settings = settings;
 }
Esempio n. 28
0
 public EmailNotificationService(IEmailSettings emailSettings)
 {
     this.emailSettings = emailSettings;
 }
Esempio n. 29
0
 public SmtpProvider(IEmailSettings settings)
 {
     _settings = settings;
 }
Esempio n. 30
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EmailService"/> class.
 /// </summary>
 /// <param name="settings">The config.</param>
 public EmailService(IEmailSettings settings)
 {
     Init(settings);
 }
 public EmailSender(IEmailSettings settings)
 {
     m_settings = settings;
 }
Esempio n. 32
0
 public EmailService(IEmailSettings settings)
 {
     _settings = settings;
 }
Esempio n. 33
0
 /// <summary>
 /// Initialize the configuration.
 /// </summary>
 /// <param name="config"></param>
 public void Init(IEmailSettings config)
 {
     _config = config;
 }
Esempio n. 34
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EmailService"/> class.
 /// </summary>
 /// <param name="settings">The config.</param>
 public EmailService(IEmailSettings settings)
 {
     Init(settings);
 }
Esempio n. 35
0
 public EmailSender(IEmailSettings settings)
 {
     m_settings = settings;
 }
Esempio n. 36
0
 public EmailSender(IEmailSettings emailSettings)
 {
     _emailSettings = emailSettings;
 }
Esempio n. 37
0
 public EmailNotifier(IEmailSettings settings, ISmtpProvider smtpProvider, ILogger logger)
 {
     _settings     = settings;
     _smtpProvider = smtpProvider;
     _logger       = logger;
 }
Esempio n. 38
0
 public EmailService(
     IEmailSettings emailSettings)
 {
     _emailSettings = emailSettings;
 }