/// <summary> /// <para>Adds a notification recipient for an account.</para> /// </summary> /// <param name="accountId">The id of the account for which a recipient should be added.</param> /// <param name="twitterHandle">The twitter handle for the recipient.</param> /// <param name="description">A short description for the recipient.</param> /// <returns>Returns a validation result object.</returns> internal IValidationResult AddNotificationRecipient(int accountId, string twitterHandle, string description) { IValidationResult validationResult = new ValidationResult(); // Populate a new account object. NotificationRecipient newNotificationRecipient = new NotificationRecipient(); // Populate the remaining properties. newNotificationRecipient.AccountId = accountId; newNotificationRecipient.TwitterHandle = twitterHandle; newNotificationRecipient.Description = description; newNotificationRecipient.ReceivesDailySummary = true; newNotificationRecipient.ReceivesAlerts = true; newNotificationRecipient.AlertIntervalHours = 12; newNotificationRecipient.Method = NotificationMethod.DirectMessage; newNotificationRecipient.LastAlert = DateTime.UtcNow; // Validate the new notification recipient. validationResult = this.doctrineShipsValidation.NotificationRecipient(newNotificationRecipient); if (validationResult.IsValid == true) { // Add the new notification recipient. this.doctrineShipsRepository.CreateNotificationRecipient(newNotificationRecipient); this.doctrineShipsRepository.Save(); // Log the addition. logger.LogMessage("Notification Recipient '" + newNotificationRecipient.Description + "' Successfully Added For Account Id: " + newNotificationRecipient.AccountId, 2, "Message", MethodBase.GetCurrentMethod().Name); } return(validationResult); }
private async Task SendToRecipientAsync( Notification notification, NotificationRecipient recipient, string message) { if (notification is EmailNotification email) { await _emailSender.SendEmailAsync(new EmailModel { Recipients = new[] { new Address( recipient.RecipientName, recipient.RecipientIdentifier) }, Subject = email.Subject, HtmlBody = message }); } if (notification is SmsNotification) { await _smsSender.SendSmsAsync(recipient.RecipientIdentifier, message); } }
public NotificationSendLogRow CreateNotificationMessage(Notification notification, string composedContent, string composedSubject, NotificationRecipient rec, NotificationMessageTemplateTypeDictionary notificationMessageTemplateType, Guid tryGroupId) { var status = SendStatusDictionary.ErrorOnCompose; string sendedSubject = ""; string sendedContent = ""; if (composedContent != null && composedSubject != null) { status = SendStatusDictionary.NeedToSend; sendedSubject = composedSubject; sendedContent = composedContent; } var rez = new NotificationSendLogRow { Notification = notification, Recipient = rec, SendDateTime = DateTime.Now, SendTryGroupId = tryGroupId, SendType = notificationMessageTemplateType, SendStatus = status, SendedSubject = sendedSubject, SendedContent = sendedContent, }; return rez; }
public ActionResult UpdateNotificationRecipients(AccountNotificationRecipientsViewModel viewModel) { if (viewModel != null) { // Create an Auto Mapper map between the notification recipient entity and the view model. Mapper.CreateMap <AccountNotificationRecipientsViewModel, NotificationRecipient>(); // Convert the currently logged-in account id to an integer. viewModel.AccountId = Conversion.StringToInt32(User.Identity.Name); // Populate a notification recipient with automapper and pass it back to the service layer for update. NotificationRecipient notificationRecipient = Mapper.Map <AccountNotificationRecipientsViewModel, NotificationRecipient>(viewModel); IValidationResult validationResult = this.doctrineShipsServices.UpdateNotificationRecipient(notificationRecipient); // If the validationResult is not valid, something did not validate in the service layer. if (validationResult.IsValid) { TempData["Status"] = "The notification recipient was successfully updated."; } else { TempData["Status"] = "Error: The notification recipient was not updated, a validation error occured.<br /><b>Error Details: </b>"; foreach (var error in validationResult.Errors) { TempData["Status"] += error.Value + "<br />"; } } } return(RedirectToAction("NotificationRecipients")); }
/// <summary> /// Updates a notification recipient for a particular account. /// </summary> /// <param name="notificationRecipient">A partially populated notification recipient object to be updated.</param> /// <returns>Returns a validation result object.</returns> internal IValidationResult UpdateNotificationRecipient(NotificationRecipient notificationRecipient) { IValidationResult validationResult = new ValidationResult(); var existingNotificationRecipient = this.doctrineShipsRepository.GetNotificationRecipient(notificationRecipient.NotificationRecipientId); if (existingNotificationRecipient != null) { if (existingNotificationRecipient.AccountId != notificationRecipient.AccountId) { validationResult.AddError("NotificationRecipient.Permission", "The notification recipient being modified does not belong to the requesting account."); } else { // Map the updates to the existing notification recipient. existingNotificationRecipient.AlertIntervalHours = notificationRecipient.AlertIntervalHours; existingNotificationRecipient.ReceivesAlerts = notificationRecipient.ReceivesAlerts; existingNotificationRecipient.ReceivesDailySummary = notificationRecipient.ReceivesDailySummary; // Validate the notification recipient updates. validationResult = this.doctrineShipsValidation.NotificationRecipient(existingNotificationRecipient); if (validationResult.IsValid == true) { // Update the existing record, save and log. this.doctrineShipsRepository.UpdateNotificationRecipient(existingNotificationRecipient); this.doctrineShipsRepository.Save(); logger.LogMessage("Notification Recipient '" + existingNotificationRecipient.Description + "' Successfully Updated For Account Id: " + existingNotificationRecipient.AccountId, 2, "Message", MethodBase.GetCurrentMethod().Name); } } } return(validationResult); }
/// <summary> /// Add the EmailSource. /// </summary> private static void AddEmailSource(PXGraph graph, int?sourceEmailID, RecipientList recipients) { NotificationRecipient recipient = null; EMailAccount emailAccountRow = PXSelect <EMailAccount, Where < EMailAccount.emailAccountID, Equal <Required <EMailAccount.emailAccountID> > > > .Select(graph, sourceEmailID); if (emailAccountRow != null && emailAccountRow.Address != null) { recipient = new NotificationRecipient() { Active = true, Email = emailAccountRow.Address, Hidden = false, Format = "H" }; if (recipient != null) { recipients.Add(recipient); } } }
internal IValidationResult NotificationRecipient(NotificationRecipient notificationRecipient) { IValidationResult validationResult = new ValidationResult(); // Null checks. if (notificationRecipient.TwitterHandle == null) { validationResult.AddError("TwitterHandle.Null", "TwitterHandle cannot be null."); } if (notificationRecipient.Description == null || notificationRecipient.Description == string.Empty) { validationResult.AddError("Description.Null", "Description cannot be null or an empty string."); } // Regex checks. if (notificationRecipient.TwitterHandle != null) { if (!Regex.Match(notificationRecipient.TwitterHandle, "^@(\\w){1,15}$").Success) { validationResult.AddError("TwitterHandle.Format", "Invalid twitter handle."); } } // Range checks. if (notificationRecipient.AlertIntervalHours < 1 || notificationRecipient.AlertIntervalHours > 168) { validationResult.AddError("AlertIntervalHours.Range", "AlertIntervalHours is outside of expected ranges. AlertIntervalHours should be between 1 and 168 hours (one week)."); } return(validationResult); }
private async Task PublishViaMethod(Notification notification, NotificationMethod method, int userId) { NotificationRecipient model = null; switch (method) { case NotificationMethod.Default: { model = new NotificationRecipient() { Method = method, NotificationId = notification.Id, ToUserId = userId, }; } break; case NotificationMethod.Email: { model = new NotificationRecipient() { Method = method, NotificationId = notification.Id, ToUserId = userId, WhenDelivered = DateTime.UtcNow, }; // send email; // notification.DeliveryCount++; // delivery successful } break; case NotificationMethod.SMS: { model = new NotificationRecipient() { Method = method, NotificationId = notification.Id, ToUserId = userId, WhenDelivered = DateTime.UtcNow, WhenViewed = DateTime.UtcNow, WhenDismissed = DateTime.UtcNow, }; // send text; //notification.DeliveryCount++; // delivery successful } break; } if (model != null) { await _db.Recipients.AddAsync(model); await _db.SaveChangesAsync(); } }
public async Task UpdateNotificationRecipientAsync(NotificationRecipient recipient) { if (recipient == null) { throw new ArgumentNullException(nameof(recipient)); } await _context.UpdateAsync(recipient); }
private async Task <List <NotificationRecipient> > GetRecipientsAsync( NotificationType notificationType, int eventId, int?productId, Registration.RegistrationStatus[] registrationStatuses, Registration.RegistrationType[] registrationTypes) { var recipients = new List <NotificationRecipient>(); // Default status if not provided: Verified, attended and finished registrationStatuses ??= new[] { Registration.RegistrationStatus.Verified, Registration.RegistrationStatus.Attended, Registration.RegistrationStatus.Finished }; // Default registration type is participants registrationTypes ??= new[] { Registration.RegistrationType.Participant }; var reader = new PageReader <Registration>(async(offset, limit, token) => await _registrationRetrievalService.ListRegistrationsAsync( new RegistrationListRequest { Limit = limit, Offset = offset, Filter = new RegistrationFilter { EventInfoId = eventId, ProductIds = productId.HasValue ? new[] { productId.Value } : null, ActiveUsersOnly = true, HavingStatuses = registrationStatuses, HavingTypes = registrationTypes } }, new RegistrationRetrievalOptions { LoadUser = true, ForUpdate = true }, token)); while (await reader.HasMoreAsync()) { recipients.AddRange((from registration in await reader .ReadNextAsync() select NotificationRecipient.Create(registration, notificationType)) .Where(r => r != null)); // user may have no phone, or email } return(recipients); }
internal static void AddNotificationRecipient(AdminCenterClient adminCenterClient, string emailAddress, string name) { var notificationRecipient = new NotificationRecipient { Email = emailAddress, Name = name, }; NotificationRecipient addedNotificationRecipient = adminCenterClient.SetNotificationRecipient(notificationRecipient); Utils.ConsoleWriteLineAsJson(addedNotificationRecipient); }
/// <summary> /// Add the Customer info as a recipient in the Email template generated by Appointment. /// </summary> private static void AddCustomerRecipient(AppointmentEntry graphAppointmentEntry, NotificationRecipient recSetup, RecipientList recipients) { NotificationRecipient recipient = null; Customer customerRow = PXSelect <Customer, Where < Customer.bAccountID, Equal <Required <Customer.bAccountID> > > > .Select(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.CustomerID); if (customerRow == null) { return; } FSxCustomer fsxCustomerRow = PXCache <Customer> .GetExtension <FSxCustomer>(customerRow); if (fsxCustomerRow.SendAppNotification == true) { if (graphAppointmentEntry.ServiceOrderRelated.Current.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = graphAppointmentEntry.ServiceOrderRelated.Current.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; } else { Contact srvOrdContactRow = PXSelect <Contact, Where < Contact.contactID, Equal <Required <Contact.contactID> > > > .Select(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.ContactID); if (srvOrdContactRow != null && srvOrdContactRow.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = srvOrdContactRow.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; } } if (recipient != null) { recipients.Add(recipient); } } }
public async Task <IActionResult> PostNotificationRecipient([FromBody] NotificationRecipient notificationRecipient) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.NotificationRecipient.Add(notificationRecipient); await _context.SaveChangesAsync(); return(CreatedAtAction("GetNotificationRecipient", new { id = notificationRecipient.Id }, notificationRecipient)); }
/// <summary> /// Add the Employee(s) info as a recipient(s) in the Email template generated by Appointment. /// </summary> private static void AddEmployeeStaffRecipient(AppointmentEntry graphAppointmentEntry, int?bAccountID, string type, NotificationRecipient recSetup, RecipientList recipients) { NotificationRecipient recipient = null; Contact contactRow = null; if (type == BAccountType.EmployeeType) { contactRow = PXSelectJoin <Contact, InnerJoin <BAccount, On < BAccount.parentBAccountID, Equal <Contact.bAccountID>, And <BAccount.defContactID, Equal <Contact.contactID> > > >, Where < BAccount.bAccountID, Equal <Required <BAccount.bAccountID> >, And < BAccount.type, Equal <Required <BAccount.type> > > > > .Select(graphAppointmentEntry, bAccountID, type); } else if (type == BAccountType.VendorType) { contactRow = PXSelectJoin <Contact, InnerJoin <BAccount, On < Contact.contactID, Equal <BAccount.defContactID> > >, Where < BAccount.bAccountID, Equal <Required <BAccount.bAccountID> >, And < BAccount.type, Equal <Required <BAccount.type> > > > > .Select(graphAppointmentEntry, bAccountID, type); } if (contactRow != null && contactRow.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = contactRow.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; if (recipient != null) { recipients.Add(recipient); } } }
private void PopulateRecipientStackPanel() { //First clear the stackpanel. RecipientEmailsStack.Children.Clear(); SettingsPropertyCollection settings = Properties.RecipientSettings.Default.Properties; foreach (SettingsProperty setting in settings) { NotificationRecipient recipient = new NotificationRecipient(); recipient.RecipientEmail.Text = setting.DefaultValue.ToString(); RecipientEmailsStack.Children.Add(recipient); } }
public async void CreateNewNotification(string messageBody) { var activity = new NotificationRecipient() { Id = Guid.NewGuid().ToString(), MessageBody = messageBody, DateSaved = DateTime.UtcNow }; using (var reps = new AccessCosmos.NotificationRepository()) { await reps.CreateAsync(activity); } }
public static void CheckNotificationRecipient(this JToken token, NotificationRecipient recipient) { Assert.NotEmpty(token); Assert.Equal(recipient.RecipientId, token.Value <int>("recipientId")); Assert.Equal(recipient.NotificationId, token.Value <int>("notificationId")); Assert.Equal(recipient.RecipientUserId, token.Value <string>("recipientUserId")); Assert.Equal(recipient.RegistrationId, token.Value <int?>("registrationId")); Assert.Equal(recipient.RecipientName, token.Value <string>("recipientName")); Assert.Equal(recipient.RecipientIdentifier, token.Value <string>("recipientIdentifier")); Assert.Equal(recipient.Created.ToString("yyyy-MM-ddTHH:mm:ss"), token.Value <DateTime>("created").ToString("yyyy-MM-ddTHH:mm:ss")); Assert.Equal(recipient.Sent?.ToString("yyyy-MM-ddTHH:mm:ss"), token.Value <DateTime?>("sent")?.ToString("yyyy-MM-ddTHH:mm:ss")); Assert.Equal(recipient.Errors, token.Value <string>("errors")); }
/// <summary> /// Add the Employee email that has assigned the salesperson as a recipient in the Email template generated by Appointment. /// </summary> private static void AddSalespersonRecipient(AppointmentEntry graphAppointmentEntry, NotificationRecipient recSetup, RecipientList recipients) { NotificationRecipient recipient = null; bool?appNotification = false; PXResult <SalesPerson, EPEmployee, BAccount, Contact> bqlResult = (PXResult <SalesPerson, EPEmployee, BAccount, Contact>) PXSelectJoin <SalesPerson, InnerJoin <EPEmployee, On <EPEmployee.salesPersonID, Equal <SalesPerson.salesPersonID> >, InnerJoin <BAccount, On <BAccount.bAccountID, Equal <EPEmployee.bAccountID> >, InnerJoin <Contact, On <BAccount.parentBAccountID, Equal <Contact.bAccountID>, And <BAccount.defContactID, Equal <Contact.contactID> > > > > >, Where < SalesPerson.salesPersonID, Equal <Required <FSAppointment.salesPersonID> > > > .Select(graphAppointmentEntry, graphAppointmentEntry.AppointmentRecords.Current.SalesPersonID); Contact contactRow = (Contact)bqlResult; BAccount baccountRow = (BAccount)bqlResult; EPEmployee epEmployeeRow = (EPEmployee)bqlResult; SalesPerson SalespersonRow = (SalesPerson)bqlResult; if (epEmployeeRow != null && SalespersonRow != null) { FSxEPEmployee fsxEpEmployeeRow = PXCache <EPEmployee> .GetExtension <FSxEPEmployee>(epEmployeeRow); appNotification = fsxEpEmployeeRow.SendAppNotification; if (appNotification == true) { if (contactRow != null && contactRow.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = contactRow.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; if (recipient != null) { recipients.Add(recipient); } } } } }
/// <summary> /// Executes the specified context. /// </summary> /// <param name="context">The context.</param> public virtual void Execute(IJobExecutionContext context) { JobDataMap dataMap = context.JobDetail.JobDataMap; var groupGuid = dataMap.Get("NotificationGroup").ToString().AsGuid(); var rockContext = new RockContext(); var group = new GroupService(rockContext).Get(groupGuid); if (group != null) { var notifications = Utility.SparkLinkHelper.SendToSpark(rockContext); if (notifications.Count == 0) { return; } var notificationService = new NotificationService(rockContext); foreach (var notification in notifications.ToList()) { if (notificationService.Get(notification.Guid) == null) { notificationService.Add(notification); } else { notifications.Remove(notification); } } rockContext.SaveChanges(); var notificationRecipientService = new NotificationRecipientService(rockContext); foreach (var notification in notifications) { foreach (var member in group.Members) { if (member.Person.PrimaryAliasId.HasValue) { var recipientNotification = new NotificationRecipient(); recipientNotification.NotificationId = notification.Id; recipientNotification.PersonAliasId = member.Person.PrimaryAliasId.Value; notificationRecipientService.Add(recipientNotification); } } } rockContext.SaveChanges(); } }
/// <summary> /// Add the Employee info defined in the Notification tab defined in the <c>SrvOrdType</c> as a recipient(s) in the Email template generated by Appointment. /// </summary> private static void AddEmployeeRecipient(PXGraph graph, NotificationRecipient recSetup, RecipientList recipients) { NotificationRecipient recipient = null; bool?appNotification = false; PXResult <Contact, BAccount, EPEmployee> bqlResult = (PXResult <Contact, BAccount, EPEmployee>) PXSelectJoin <Contact, InnerJoin <BAccount, On <Contact.bAccountID, Equal <BAccount.parentBAccountID>, And <Contact.contactID, Equal <BAccount.defContactID> > >, InnerJoin <EPEmployee, On <EPEmployee.bAccountID, Equal <BAccount.bAccountID> > > >, Where < Contact.contactID, Equal <Required <Contact.contactID> >, And <BAccount.type, Equal <Required <BAccount.type> > > > > .Select(graph, recSetup.ContactID, BAccountType.EmployeeType); Contact contactRow = (Contact)bqlResult; BAccount baccountRow = (BAccount)bqlResult; EPEmployee epEmployeeRow = (EPEmployee)bqlResult; if (epEmployeeRow != null) { FSxEPEmployee fsxEpEmployeeRow = PXCache <EPEmployee> .GetExtension <FSxEPEmployee>(epEmployeeRow); appNotification = fsxEpEmployeeRow.SendAppNotification; if (appNotification == true) { if (contactRow != null && contactRow.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = contactRow.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; if (recipient != null) { recipients.Add(recipient); } } } } }
public NotificationRecipientDto(NotificationRecipient recipient) { if (recipient == null) { throw new ArgumentNullException(nameof(recipient)); } RecipientId = recipient.RecipientId; NotificationId = recipient.NotificationId; RecipientUserId = recipient.RecipientUserId; RegistrationId = recipient.RegistrationId; RecipientName = recipient.RecipientName; RecipientIdentifier = recipient.RecipientIdentifier; Created = recipient.Created; Sent = recipient.Sent; Errors = recipient.Errors; }
public void WithNotificationDelayGtLastNotificationSentAtReturnsCorrectResult() { //Arrange var sentAt = DateTime.UtcNow.AddMinutes(-5); User user = new User { EmailAdress = "*****@*****.**" }; Notification notification = new Notification { IsEnabled = true, Name = "Test Notification", Type = NotificationType.Warning }; NotificationRecipient notificationRecipient = new NotificationRecipient { Delay = new TimeSpan(0, 0, 30), DeliveryMode = DeliveryMode.Email, Notification = notification, NotificationsPerEvent = 5, User = user }; NotificationEvent notificationEvent = new NotificationEvent { Active = true, LastAlertTime = DateTime.UtcNow, Notification = notification, Value = "Test Failed" }; NotificationEventLog notificationEventLog = new NotificationEventLog { NotificationEvent = notificationEvent, NotificationRecipient = notificationRecipient, SentAt = sentAt }; NotificationEvent result; using (var context = new AppDbContext()) { context.Users.Add(user); context.NotificationEventLogs.Add(notificationEventLog); context.SaveChanges(); } //Act using (var context = new AppDbContext()) { result = context.NotificationEvents.WithNotificationDelayGtLastNotificationSentAt(DateTime.UtcNow).FirstOrDefault(); } using (var context = new AppDbContext()) { context.NotificationEventLogs.Remove(notificationEventLog); context.NotificationEvents.Remove(notificationEvent); context.NotificationRecipients.Remove(notificationRecipient); context.Notifications.Remove(notification); context.Users.Remove(user); context.SaveChanges(); } //Assert Assert.IsNotNull(result); }
/// <summary> /// Add the Vendor(s) info as a recipient(s) in the Email template generated by Appointment. /// </summary> private static void AddVendorStaffRecipient(AppointmentEntry graphAppointmentEntry, FSAppointmentEmployee fsAppointmentEmployee, NotificationRecipient recSetup, RecipientList recipients) { //TODO: AC-142850 6082 validate Vendor's AppNotification flag /* * select * from Contact * inner join BAccount on (BAccount.BAccountID = Contact.BAccountID * and BAccount.DefContactID = Contact.ContactID) * where * BAccount.BAccountID = xx * and BAccount.Type = 'VE' */ //BAccountType.VendorType }
public void SendSensorNotificationsWithActiveNotifyingEventSensEmail() { var lastAlertTime = DateTime.UtcNow.AddMinutes(-5); var notification = new Notification { IsEnabled = true, Type = NotificationType.Warning, Name = "Test Notification" }; var notificationEvent = new NotificationEvent { LastAlertTime = lastAlertTime, Notification = notification, Active = true, Value = "Alert 1" }; var user = new User { EmailAdress = "*****@*****.**" }; var recipient = new NotificationRecipient { User = user, Delay = new TimeSpan(0, 0, 30), DeliveryMode = DeliveryMode.Email, Notification = notification }; //Setup Mock for Add var mockSet = new Mock <DbSet <NotificationEventLog> >(); var mockContext = new Mock <AppDbContext>(); mockContext.Setup(m => m.NotificationEventLogs).Returns(mockSet.Object); var mockEmailService = new Mock <IMessageService>(); var mockNotificationEventService = new Mock <INotificationEventService>(); mockNotificationEventService.Setup(m => m.GetActiveSignalingNotificationEvents(It.IsAny <DateTime>())).Returns(new List <NotificationEvent> { notificationEvent }); mockNotificationEventService.Setup(m => m.GetActiveSignallingRecipientsForNotificationEvent(notificationEvent, It.IsAny <DateTime>())).Returns(new List <NotificationRecipient> { recipient }); //Act var sensorNotificationService = new NotificationService(mockContext.Object, mockNotificationEventService.Object, mockEmailService.Object, null); sensorNotificationService.SendNotifications(DateTime.UtcNow); //Assert mockSet.Verify(m => m.Add(It.IsAny <NotificationEventLog>()), Times.Once()); mockContext.Verify(m => m.SaveChangesAsync(), Times.Once()); mockEmailService.Verify(m => m.SendAsync(It.IsAny <Message>()), Times.Once); }
/// <summary> /// Add the Billing Customer info as a recipient(s) in the Email template generated by Appointment. /// </summary> private static void AddBillingRecipient(AppointmentEntry graphAppointmentEntry, NotificationRecipient recSetup, RecipientList recipients) { NotificationRecipient recipient = null; if (graphAppointmentEntry.ServiceOrderRelated.Current.BillCustomerID != null) { Customer customerRow = PXSelect <Customer, Where < Customer.bAccountID, Equal <Required <Customer.bAccountID> > > > .Select(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.BillCustomerID); if (customerRow == null) { return; } Contact contactRow = PXSelectJoin <Contact, InnerJoin <Customer, On < Contact.bAccountID, Equal <Customer.bAccountID>, And <Contact.contactID, Equal <Customer.defBillContactID> > > >, Where < Customer.bAccountID, Equal <Required <Customer.bAccountID> > > > .Select(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.BillCustomerID); if (contactRow != null && contactRow.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = contactRow.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; } } if (recipient != null) { recipients.Add(recipient); } }
private void SendEmail(NotificationRecipient notificationRecipient, NotificationSourceModel notificationSourceModel, ComplianceDocument complianceDocument) { var email = RecipientEmailDataProvider .GetRecipientEmail(notificationRecipient, notificationSourceModel.VendorId); if (email != null) { var report = GetReportInAppropriateFormat(notificationRecipient.Format, notificationSourceModel, complianceDocument); var sender = TemplateNotificationGenerator.Create(complianceDocument, notificationSourceModel.NotificationSource.NotificationID); sender.MailAccountId = notificationSourceModel.NotificationSource.EMailAccountID; sender.RefNoteID = complianceDocument.NoteID; sender.To = email; sender.AddAttachmentLink(report.ReportFileInfo.UID.GetValueOrDefault()); sender.Send(); UpdateLienWaiverProcessedStatus(complianceDocument); } }
/// <summary> /// <para>Deletes a notification recipient from an accountId and a notificationRecipientId.</para> /// </summary> /// <param name="accountId">The account Id of the requestor. The account Id should own the notification recipient being deleted.</param> /// <param name="notificationRecipientId">The Id of the notification recipient to be deleted.</param> /// <returns>Returns true if the deletion was successful or false if not.</returns> internal bool DeleteNotificationRecipient(int accountId, int notificationRecipientId) { NotificationRecipient notificationRecipient = this.doctrineShipsRepository.GetNotificationRecipient(notificationRecipientId); if (notificationRecipient != null) { // If the account Id matches the account Id of the notification recipient being deleted, continue. if (accountId == notificationRecipient.AccountId) { // Delete the notification recipient and log the event. this.doctrineShipsRepository.DeleteNotificationRecipient(notificationRecipient.NotificationRecipientId); this.doctrineShipsRepository.Save(); logger.LogMessage("Notification Recipient '" + notificationRecipient.Description + "' Successfully Deleted For Account Id: " + notificationRecipient.AccountId, 1, "Message", MethodBase.GetCurrentMethod().Name); return(true); } } return(false); }
public string GetRecipientEmail(NotificationRecipient notificationRecipient, int?vendorId) { switch (notificationRecipient.ContactType) { case NotificationContactType.Primary: return(GetEmailForPrimaryVendor(vendorId)); case NotificationContactType.Employee: return(GetContactEmail(notificationRecipient.ContactID)); case NotificationContactType.Remittance: return(GetEmailForRemittanceContact(vendorId)); case NotificationContactType.Shipping: return(GetEmailForShippingContact(vendorId)); default: return(GetContactEmail(notificationRecipient.ContactID)); } }
public void WithNotificationDelayGtLastNotificationSentAtReturnsCorrectResult() { var sentAt = DateTime.UtcNow.AddMinutes(-5); var notification = new Notification { IsEnabled = true }; var notificationRecipient1 = new NotificationRecipient { Delay = new TimeSpan(0, 0, 10), Notification = notification }; var notificationEvent1 = new NotificationEvent { Notification = notification, Active = true }; var notificationEventLog1 = new NotificationEventLog { NotificationEvent = notificationEvent1, NotificationRecipient = notificationRecipient1, SentAt = sentAt }; var notificationRecipients = new List <NotificationRecipient> { notificationRecipient1 }; var notificationEvents = new List <NotificationEvent> { notificationEvent1 }; var notificationEventLogs = new List <NotificationEventLog> { notificationEventLog1 }; //Add collections notification.NotificationRecipients = notificationRecipients; notification.NotificationEvents = notificationEvents; notificationEvent1.NotificationEventLogs = notificationEventLogs; notificationRecipient1.NotificationEventLogs = notificationEventLogs; var result = notificationEvents.AsQueryable().WithNotificationDelayGtLastNotificationSentAt(DateTime.UtcNow).FirstOrDefault(); Assert.IsNotNull(result); }
/// <summary> /// Add the Employee(s) info as a recipient(s) in the Email template generated by Appointment. /// </summary> private static void AddEmployeeStaffRecipient( AppointmentEntry graphAppointmentEntry, int?bAccountID, string type, NotificationRecipient recSetup, RecipientList recipients) { NotificationRecipient recipient = null; bool? appNotification = false; Contact contactRow = null; if (type == BAccountType.EmployeeType) { EPEmployee epEmployeeRow = PXSelect <EPEmployee, Where < EPEmployee.bAccountID, Equal <Required <EPEmployee.bAccountID> > > > .Select(graphAppointmentEntry, bAccountID); FSxEPEmployee fsxEpEmployeeRow = PXCache <EPEmployee> .GetExtension <FSxEPEmployee>(epEmployeeRow); appNotification = fsxEpEmployeeRow.SendAppNotification; contactRow = PXSelectJoin <Contact, InnerJoin <BAccount, On <BAccount.parentBAccountID, Equal <Contact.bAccountID>, And <BAccount.defContactID, Equal <Contact.contactID> > > >, Where < BAccount.bAccountID, Equal <Required <BAccount.bAccountID> >, And <BAccount.type, Equal <Required <BAccount.type> > > > > .Select(graphAppointmentEntry, bAccountID, type); } else if (type == BAccountType.VendorType) { Vendor vendorRow = PXSelect <Vendor, Where < Vendor.bAccountID, Equal <Required <Vendor.bAccountID> > > > .Select(graphAppointmentEntry, bAccountID); FSxVendor fsxVendorRow = PXCache <Vendor> .GetExtension <FSxVendor>(vendorRow); appNotification = fsxVendorRow.SendAppNotification; contactRow = PXSelectJoin <Contact, InnerJoin <BAccount, On <Contact.contactID, Equal <BAccount.defContactID> > >, Where < BAccount.bAccountID, Equal <Required <BAccount.bAccountID> >, And <BAccount.type, Equal <Required <BAccount.type> > > > > .Select(graphAppointmentEntry, bAccountID, type); } if (appNotification == true) { if (contactRow != null && contactRow.EMail != null) { recipient = new NotificationRecipient() { Active = true, Email = contactRow.EMail, Hidden = recSetup.Hidden, Format = recSetup.Format }; if (recipient != null) { recipients.Add(recipient); } } } }
/// <summary> /// Adds the Employee(s) belonging to the Appointment's Service Area as recipients in the Email template generated by Appointment. /// </summary> private static void AddGeoZoneStaffRecipient(AppointmentEntry graphAppointmentEntry, NotificationRecipient recSetup, RecipientList recipients) { List <FSGeoZoneEmp> geoZoneEmpList = new List <FSGeoZoneEmp>(); if (graphAppointmentEntry.ServiceOrderRelated.Current.PostalCode != null) { FSGeoZonePostalCode fsGeoZoneRow = StaffSelectionHelper.GetMatchingGeoZonePostalCode(graphAppointmentEntry, graphAppointmentEntry.ServiceOrderRelated.Current.PostalCode); if (fsGeoZoneRow != null) { var fsGeoZonePostalCodeSet = PXSelectJoin <FSGeoZonePostalCode, InnerJoin <FSGeoZoneEmp, On <FSGeoZoneEmp.geoZoneID, Equal <FSGeoZonePostalCode.geoZoneID> > >, Where < FSGeoZonePostalCode.postalCode, Equal <Required <FSGeoZonePostalCode.postalCode> > > > .Select(graphAppointmentEntry, fsGeoZoneRow.PostalCode); foreach (PXResult <FSGeoZonePostalCode, FSGeoZoneEmp> bqlResult in fsGeoZonePostalCodeSet) { geoZoneEmpList.Add((FSGeoZoneEmp)bqlResult); } } } List <FSGeoZoneEmp> fsGeoZoneEmpGroupByEmployeeID = geoZoneEmpList.GroupBy(x => x.EmployeeID).Select(grp => grp.First()).ToList(); if (fsGeoZoneEmpGroupByEmployeeID.Count > 0) { foreach (FSGeoZoneEmp fsGeoZoneEmpRow in fsGeoZoneEmpGroupByEmployeeID) { AddEmployeeStaffRecipient(graphAppointmentEntry, fsGeoZoneEmpRow.EmployeeID, BAccountType.EmployeeType, recSetup, recipients); } } }