Esempio n. 1
0
        public async Task <IActionResult> OrderEmails([FromRoute] int eventId, [FromServices] StandardEmailSender emailSender, [FromServices] IRegistrationService registrationService, [FromBody] EmailVm vm)
        {
            var registrations = await registrationService.GetRegistrationsWithOrders(eventId);

            var emailTasks = registrations.Select(r =>
            {
                var message = new EmailMessage
                {
                    Name    = r.ParticipantName,
                    Email   = r.User.Email,
                    Subject = vm.Subject,
                    Message = vm.Message
                };
                if (r.HasOrder)
                {
                    StringBuilder builder = new StringBuilder();
                    builder.AppendLine("<br>");
                    builder.AppendLine("<h4>Ordre</h4>");

                    r.Orders.ForEach(
                        (o) => o.OrderLines?.ForEach(
                            (line) => builder.AppendLine($"<br>{line.ProductName}")
                            )
                        );

                    message.Message += builder.ToString();
                }
                return(emailSender.SendStandardEmailAsync(message));
            });
            await Task.WhenAll(emailTasks);

            return(Ok());
        }
Esempio n. 2
0
        public async Task <IActionResult> EmailCertificate([FromRoute] int regId, [FromServices] CertificatePdfRenderer writer, [FromServices] StandardEmailSender emailSender)
        {
            var c = await _certificatesService.GetForRegistrationAsync(regId);

            var result = await writer.RenderAsync(CertificateVM.From(c));

            var memoryStream = new MemoryStream();
            await result.CopyToAsync(memoryStream);

            var emailMessage = new EmailMessage
            {
                Email      = c.RecipientEmail,
                Subject    = $"Kursbevis for {c.Title}",
                Message    = "Her er kursbeviset! Gratulere!",
                Attachment = new Attachment
                {
                    Filename    = "kursbevis.pdf",
                    Bytes       = memoryStream.ToArray(),
                    ContentType = "application/pdf"
                }
            };
            await emailSender.SendStandardEmailAsync(emailMessage);

            return(Ok());
        }
        public async Task <IActionResult> OnGetAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var registration = await _registrationService.GetWithUserAndEventInfoAsync(id.Value);

            if (registration == null)
            {
                return(NotFound());
            }

            if (HttpContext.Request.Query["auth"] == registration.VerificationCode)
            {
                if (registration.Status == RegistrationStatus.Draft || registration.Status == RegistrationStatus.Cancelled)
                {
                    await _registrationService.SetRegistrationAsVerified(id.Value);
                }

                // Send a copy to admin TODO: Read from appsettings
                var adminmessage = "<p>Hurra! Enda en påmelding!</p>";
                await _registrationEmailSender.SendRegistrationAsync("*****@*****.**", $"KOPI: Påmelding {registration.EventInfo.Title}", adminmessage, registration.RegistrationId);

                // Send welcome letter to participant
                var participantEmail = new EmailMessage()
                {
                    Name    = registration.ParticipantName,
                    Email   = registration.User.Email,
                    Subject = $@"Velkommen til {registration.EventInfo.Title}!",
                    Message = registration.EventInfo.WelcomeLetter
                };

                await _standardEmailSender.SendStandardEmailAsync(participantEmail);

                return(RedirectToPage("./Confirmed"));
            }

            // If we came here, something has went wrong.
            return(RedirectToPage("./Failed"));
        }
        public async Task <IActionResult> GenerateCertificatesAndSendEmails([FromRoute] int eventId, [FromServices] CertificatePdfRenderer writer, [FromServices] StandardEmailSender emailSender)
        {
            var certificates = await _certificatesService.CreateCertificatesForEvent(eventId);

            foreach (var certificate in certificates)
            {
                var result = await writer.RenderAsync(CertificateVM.From(certificate));

                var memoryStream = new MemoryStream();
                await result.CopyToAsync(memoryStream);

                await emailSender.SendStandardEmailAsync(new EmailMessage {
                    Email      = certificate.RecipientEmail,
                    Subject    = $"Kursbevis for {certificate.Title}",
                    Message    = "Her er kursbeviset! Gratulere!",
                    Attachment = new Attachment {
                        Filename = "kursbevis.pdf", Bytes = memoryStream.ToArray()
                    }
                });
            }
            return(Ok());
        }