/// <summary>
/// Handles the Click event of the btnSendEmail control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnSendEmail_Click(object sender, EventArgs e)
{
int sendCount = 0;
foreach (RepeaterItem repeaterItem in rptRecipients.Items)
{
CheckBox cbEmailRecipient = (CheckBox)repeaterItem.FindControl("cbEmailRecipient");
if (cbEmailRecipient != null && cbEmailRecipient.Checked)
{
int?registrationId = cbEmailRecipient.Attributes["Id"].AsIntegerOrNull();
if (registrationId.HasValue)
{
var registration = _registrants.Where(r => r.RegistrationId == registrationId).Select(r => r.Registration).FirstOrDefault();
var mergeObjects = GetMergeObjects(registration);
var emailMessage = new RockEmailMessage();
emailMessage.AdditionalMergeFields = mergeObjects;
emailMessage.FromEmail = tbFromEmail.Text;
emailMessage.FromName = tbFromName.Text;
emailMessage.Subject = tbFromSubject.Text;
emailMessage.AddRecipient(new RecipientData(registration.ConfirmationEmail, mergeObjects));
emailMessage.Message = ceEmailMessage.Text;
emailMessage.AppRoot = ResolveRockUrl("~/");
emailMessage.ThemeRoot = ResolveRockUrl("~~/");
emailMessage.Send();
sendCount++;
}
}
}
pnlSend.Visible = false;
pnlComplete.Visible = true;
nbResult.Text = string.Format("Wait List Transition emails have been sent to {0}.", "individuals".ToQuantity(sendCount));
}
private void SendEmail(List <Person> emailrecipients, Dictionary <string, object> mergeFields)
{
var message = new RockEmailMessage();
message.EnabledLavaCommands = GetAttributeValue("EnabledLavaCommands");
foreach (var person in emailrecipients)
{
if (person.Id > 0)
{
message.AddRecipient(new RockEmailMessageRecipient(person, mergeFields));
}
else
{
message.AddRecipient(RockEmailMessageRecipient.CreateAnonymous(person.Email, mergeFields));
}
}
message.FromEmail = tbEmail.Text;
message.FromName = tbFirstName.Text + " " + tbLastName.Text;
message.Subject = GetAttributeValue("Subject");
message.Message = GetAttributeValue("MessageBody");
message.AppRoot = ResolveRockUrl("~/");
message.ThemeRoot = ResolveRockUrl("~~/");
message.CreateCommunicationRecord = GetAttributeValue("SaveCommunicationHistory").AsBoolean();
message.Send();
}
private static void SendNotificationMessage(JobExecutionException jobException, ServiceJob job)
{
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null, null, new Lava.CommonMergeFieldsOptions {
GetLegacyGlobalMergeFields = false
});
mergeFields.Add("Job", job);
try
{
if (jobException != null)
{
mergeFields.Add("Exception", Hash.FromAnonymousObject(jobException));
}
}
catch
{
// ignore
}
var notificationEmailAddresses = job.NotificationEmails.ResolveMergeFields(mergeFields).SplitDelimitedValues().ToList();
var emailMessage = new RockEmailMessage(Rock.SystemGuid.SystemCommunication.CONFIG_JOB_NOTIFICATION.AsGuid());
emailMessage.AdditionalMergeFields = mergeFields;
// NOTE: the EmailTemplate may also have TO: defined, so even if there are no notificationEmailAddress defined for this specific job, we still should send the mail
foreach (var notificationEmailAddress in notificationEmailAddresses)
{
emailMessage.AddRecipient(RockEmailMessageRecipient.CreateAnonymous(notificationEmailAddress, null));
}
emailMessage.Send();
}
/// <summary>
/// Sends the invite.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="component">The component.</param>
/// <param name="document">The document.</param>
/// <param name="person">The person.</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
private bool SendInvite(RockContext rockContext, DigitalSignatureComponent component, SignatureDocument document, Person person, out List <string> errors)
{
errors = new List <string>();
if (document != null &&
document.SignatureDocumentTemplate != null &&
document.SignatureDocumentTemplate.InviteSystemCommunicationId.HasValue &&
person != null &&
!string.IsNullOrWhiteSpace(person.Email))
{
string inviteLink = component.GetInviteLink(document, person, out errors);
if (!errors.Any())
{
var systemEmail = new SystemCommunicationService(rockContext).Get(document.SignatureDocumentTemplate.InviteSystemCommunicationId.Value);
if (systemEmail != null)
{
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null, person);
mergeFields.Add("SignatureDocument", document);
mergeFields.Add("InviteLink", inviteLink);
var emailMessage = new RockEmailMessage(systemEmail);
emailMessage.AddRecipient(new RockEmailMessageRecipient(person, mergeFields));
emailMessage.Send();
}
}
else
{
return(false);
}
}
return(true);
}
private void Send(string recipients, string fromEmail, string fromName, string subject, string body, Dictionary <string, object> mergeFields, RockContext rockContext, bool createCommunicationRecord, BinaryFile[] attachments)
{
var emailMessage = new RockEmailMessage();
foreach (string recipient in recipients.SplitDelimitedValues().ToList())
{
emailMessage.AddRecipient(new RecipientData(recipient, mergeFields));
}
emailMessage.FromEmail = fromEmail;
emailMessage.FromName = fromName.IsNullOrWhiteSpace() ? fromEmail : fromName;
emailMessage.Subject = subject;
emailMessage.Message = body;
foreach (BinaryFile b in attachments)
{
if (b != null)
{
emailMessage.Attachments.Add(b);
}
}
emailMessage.CreateCommunicationRecord = createCommunicationRecord;
emailMessage.AppRoot = GlobalAttributesCache.Get().GetValue("InternalApplicationRoot") ?? string.Empty;
emailMessage.Send();
}
/// <summary>
/// Displays the confirmation.
/// </summary>
/// <param name="personId">The person identifier.</param>
private void DisplayConfirmation(int personId)
{
PersonService personService = new PersonService(new RockContext());
Person person = personService.Get(personId);
if (person != null)
{
Rock.Model.UserLogin user = CreateUser(person, false);
string url = LinkedPageUrl(AttributeKey.ConfirmationPage);
if (string.IsNullOrWhiteSpace(url))
{
url = ResolveRockUrl("~/ConfirmAccount");
}
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
mergeObjects.Add("ConfirmAccountUrl", RootPath + url.TrimStart(new char[] { '/' }));
mergeObjects.Add("Person", person);
mergeObjects.Add("User", user);
var emailMessage = new RockEmailMessage(GetAttributeValue(AttributeKey.ConfirmAccountTemplate).AsGuid());
emailMessage.AddRecipient(new RockEmailMessageRecipient(person, mergeObjects));
emailMessage.AppRoot = ResolveRockUrl("~/");
emailMessage.ThemeRoot = ResolveRockUrl("~~/");
emailMessage.CreateCommunicationRecord = false;
emailMessage.Send();
ShowPanel(4);
}
else
{
ShowErrorMessage("Invalid Person");
}
}
/// <summary>
/// Sends the confirmation.
/// </summary>
/// <param name="userLogin">The user login.</param>
private void SendConfirmation(UserLogin userLogin)
{
string url = LinkedPageUrl("ConfirmationPage");
if (string.IsNullOrWhiteSpace(url))
{
url = ResolveRockUrl("~/ConfirmAccount");
}
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(RockPage, CurrentPerson);
mergeFields.Add("ConfirmAccountUrl", RootPath + url.TrimStart('/'));
mergeFields.Add("Person", userLogin.Person);
mergeFields.Add("User", userLogin);
var recipients = new List <RecipientData>();
recipients.Add(new RecipientData(userLogin.Person.Email, mergeFields));
var message = new RockEmailMessage(GetAttributeValue("ConfirmAccountTemplate").AsGuid());
message.SetRecipients(recipients);
message.AppRoot = ResolveRockUrl("~/");
message.ThemeRoot = ResolveRockUrl("~~/");
message.CreateCommunicationRecord = false;
message.Send();
}
private void SendNotifications(List <string> alarms, Guid systemCommunication, Guid notificationGroup)
{
var emailMessage = new RockEmailMessage(systemCommunication);
var recipients = new List <RockMessageRecipient>();
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null, null);
mergeFields.Add("Alarms", alarms);
RockContext rockContext = new RockContext();
GroupService groupService = new GroupService(rockContext);
var people = groupService.Queryable()
.Where(g => g.Guid == notificationGroup)
.SelectMany(g => g.Members)
.Select(m => m.Person)
.ToList();
foreach (var person in people)
{
recipients.Add(new RockEmailMessageRecipient(person, mergeFields));
}
emailMessage.SetRecipients(recipients);
emailMessage.CreateCommunicationRecord = true;
emailMessage.Send();
}
/// <summary>
/// Sends the confirmation.
/// </summary>
/// <param name="userLogin">The user login.</param>
private void SendConfirmation(UserLogin userLogin)
{
string url = LinkedPageUrl("ConfirmationPage");
if (string.IsNullOrWhiteSpace(url))
{
url = ResolveRockUrl("~/ConfirmAccount");
}
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(null, CurrentPerson);
mergeObjects.Add("ConfirmAccountUrl", RootPath + url.TrimStart(new char[] { '/' }));
var personDictionary = userLogin.Person.ToLiquid() as Dictionary <string, object>;
mergeObjects.Add("Person", personDictionary);
mergeObjects.Add("User", userLogin);
var recipients = new List <RockMessageRecipient>();
recipients.Add(new RockEmailMessageRecipient(userLogin.Person, mergeObjects));
var emailMessage = new RockEmailMessage(GetAttributeValue("ConfirmAccountTemplate").AsGuid());
emailMessage.SetRecipients(recipients);
emailMessage.CreateCommunicationRecord = false;
emailMessage.Send();
}
private void SendConfirmation(Person person)
{
if (person == null)
{
return;
}
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
mergeObjects["Person"] = person;
mergeObjects["PublishGroup"] = _publishGroup;
mergeObjects["Group"] = _publishGroup.Group;
var message = new RockEmailMessage();
message.FromEmail = _publishGroup.ConfirmationEmail;
message.FromName = _publishGroup.ConfirmationFromName;
message.Subject = _publishGroup.ConfirmationSubject;
message.Message = _publishGroup.ConfirmationBody;
message.AddRecipient(new RecipientData(new CommunicationRecipient()
{
PersonAlias = person.PrimaryAlias
}, mergeObjects));
message.Send();
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public virtual void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
int alertPeriod = dataMap.GetInt("AlertPeriod");
Guid? systemEmailGuid = dataMap.GetString("AlertEmail").AsGuidOrNull();
List <string> recipientEmails = dataMap.GetString("AlertRecipients").SplitDelimitedValues().ToList();
if (systemEmailGuid.HasValue && recipientEmails.Any())
{
var rockContext = new RockContext();
int expirationDays = GetJobAttributeValue("ExpirationPeriod", 3, rockContext);
var cutoffTime = RockDateTime.Now.AddMinutes(0 - alertPeriod);
var communications = new CommunicationService(rockContext)
.GetQueued(expirationDays, alertPeriod, false, false)
.Where(c => !c.ReviewedDateTime.HasValue || c.ReviewedDateTime.Value.CompareTo(cutoffTime) < 0) // Make sure communication wasn't just recently approved
.OrderBy(c => c.Id)
.ToList();
if (communications.Any())
{
var mergeFields = Lava.LavaHelper.GetCommonMergeFields(null);
mergeFields.Add("Communications", communications);
var emailMessage = new RockEmailMessage(systemEmailGuid.Value);
foreach (var email in recipientEmails)
{
emailMessage.AddRecipient(new RecipientData(email, mergeFields));
}
emailMessage.Send();
}
}
}
/// <summary>
/// Sends the specified recipients.
/// </summary>
/// <param name="recipients">The recipients.</param>
/// <param name="fromEmail">From email.</param>
/// <param name="fromName">From name.</param>
/// <param name="subject">The subject.</param>
/// <param name="body">The body.</param>
/// <param name="ccEmails">The CC emails.</param>
/// <param name="bccEmails">The BCC emails.</param>
/// <param name="createCommunicationRecord">if set to <c>true</c> [create communication record].</param>
/// <param name="attachments">The attachments.</param>
/// <param name="errorMessages">The error messages.</param>
private void Send(List <RockEmailMessageRecipient> recipients, string fromEmail, string fromName, string subject, string body, List <string> ccEmails, List <string> bccEmails, bool createCommunicationRecord, BinaryFile[] attachments, out List <string> errorMessages)
{
var emailMessage = new RockEmailMessage();
emailMessage.SetRecipients(recipients);
emailMessage.FromEmail = fromEmail;
emailMessage.FromName = fromName.IsNullOrWhiteSpace() ? fromEmail : fromName;
emailMessage.Subject = subject;
emailMessage.Message = body;
emailMessage.CCEmails = ccEmails ?? new List <string>();
emailMessage.BCCEmails = bccEmails ?? new List <string>();
foreach (BinaryFile b in attachments)
{
if (b != null)
{
emailMessage.Attachments.Add(b);
}
}
emailMessage.CreateCommunicationRecord = createCommunicationRecord;
emailMessage.AppRoot = Rock.Web.Cache.GlobalAttributesCache.Get().GetValue("InternalApplicationRoot") ?? string.Empty;
emailMessage.Send(out errorMessages);
}
/// <summary>
/// Handles the Click event of the btnSendReminders control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnSendReminders_Click(object sender, EventArgs e)
{
var registrationsSelected = new List <int>();
int sendCount = 0;
gRegistrations.SelectedKeys.ToList().ForEach(r => registrationsSelected.Add(r.ToString().AsInteger()));
if (registrationsSelected.Any())
{
if (_registrationInstance == null)
{
int?registrationInstanceId = PageParameter("RegistrationInstanceId").AsIntegerOrNull();
using (RockContext rockContext = new RockContext())
{
RegistrationInstanceService registrationInstanceService = new RegistrationInstanceService(rockContext);
_registrationInstance = registrationInstanceService.Queryable("RegistrationTemplate").AsNoTracking()
.Where(r => r.Id == registrationInstanceId).FirstOrDefault();
}
foreach (var registrationId in registrationsSelected)
{
// use a new rockContext for each registration so that ChangeTracker doesn't get bogged down
using (RockContext rockContext = new RockContext())
{
var registrationService = new RegistrationService(rockContext);
var registration = registrationService.Get(registrationId);
if (registration != null && !string.IsNullOrWhiteSpace(registration.ConfirmationEmail))
{
Dictionary <string, object> mergeObjects = new Dictionary <string, object>();
mergeObjects.Add("Registration", registration);
mergeObjects.Add("RegistrationInstance", _registrationInstance);
var emailMessage = new RockEmailMessage(GetAttributeValue("ConfirmAccountTemplate").AsGuid());
emailMessage.AdditionalMergeFields = mergeObjects;
emailMessage.FromEmail = txtFromEmail.Text;
emailMessage.FromName = txtFromName.Text;
emailMessage.Subject = txtFromSubject.Text;
emailMessage.AddRecipient(registration.GetConfirmationRecipient(mergeObjects));
emailMessage.Message = ceEmailMessage.Text;
emailMessage.AppRoot = ResolveRockUrl("~/");
emailMessage.ThemeRoot = ResolveRockUrl("~~/");
emailMessage.CreateCommunicationRecord = true;
emailMessage.Send();
registration.LastPaymentReminderDateTime = RockDateTime.Now;
rockContext.SaveChanges();
sendCount++;
}
}
}
}
}
pnlSend.Visible = false;
pnlComplete.Visible = true;
nbResult.Text = string.Format("Payment reminders have been sent to {0}.", "individuals".ToQuantity(sendCount));
}
/// <summary>
/// Displays the success.
/// </summary>
/// <param name="user">The user.</param>
private void DisplaySuccess(Rock.Model.UserLogin user)
{
Authorization.SignOut();
Authorization.SetAuthCookie(tbUserName.Text, false, false);
if (user != null && user.PersonId.HasValue)
{
PersonService personService = new PersonService(new RockContext());
Person person = personService.Get(user.PersonId.Value);
if (person != null)
{
try
{
string url = LinkedPageUrl(AttributeKey.ConfirmationPage);
if (string.IsNullOrWhiteSpace(url))
{
url = ResolveRockUrl("~/ConfirmAccount");
}
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
mergeObjects.Add("ConfirmAccountUrl", RootPath + url.TrimStart(new char[] { '/' }));
mergeObjects.Add("Person", person);
mergeObjects.Add("User", user);
var emailMessage = new RockEmailMessage(GetAttributeValue(AttributeKey.AccountCreatedTemplate).AsGuid());
emailMessage.AddRecipient(new RockEmailMessageRecipient(person, mergeObjects));
emailMessage.AppRoot = ResolveRockUrl("~/");
emailMessage.ThemeRoot = ResolveRockUrl("~~/");
emailMessage.CreateCommunicationRecord = false;
emailMessage.Send();
}
catch (SystemException ex)
{
ExceptionLogService.LogException(ex, Context, RockPage.PageId, RockPage.Site.Id, CurrentPersonAlias);
}
string returnUrl = Request.QueryString["returnurl"];
btnContinue.Visible = !string.IsNullOrWhiteSpace(returnUrl);
lSuccessCaption.Text = GetAttributeValue(AttributeKey.SuccessCaption);
if (lSuccessCaption.Text.Contains("{0}"))
{
lSuccessCaption.Text = string.Format(lSuccessCaption.Text, person.FirstName);
}
ShowPanel(5);
}
else
{
ShowErrorMessage("Invalid Person");
}
}
else
{
ShowErrorMessage("Invalid User");
}
}
/// <summary>
/// Sends the confirmation e-mail to the person this <see cref="UserLogin"/>
/// is associated with. The e-mail will contain a link to the page where
/// the person can confirm they own the account.
/// </summary>
/// <param name="userLogin">The user login.</param>
/// <param name="systemEmailGuid">The system email unique identifier.</param>
/// <param name="confirmationPage">The confirmation page.</param>
/// <param name="baseUrl">The base URL to use if known, such as https://www.rockrms.com/. If <c>null</c> the default domain for the page will be used.</param>
/// <param name="mergeFields">The additional merge fields to provide.</param>
internal static void SendConfirmationEmail(UserLogin userLogin, Guid systemEmailGuid, PageCache confirmationPage, string baseUrl, Dictionary <string, object> mergeFields)
{
string url = null;
// Check for the required parameters.
if (userLogin == null)
{
throw new ArgumentNullException(nameof(userLogin));
}
if (confirmationPage == null)
{
throw new ArgumentNullException(nameof(confirmationPage));
}
// Get the default route that doesn't require any parameters.
url = confirmationPage.PageRoutes
.Where(r => !r.Route.Contains("{"))
.OrderByDescending(r => r.IsGlobal)
.Select(r => r.Route)
.FirstOrDefault();
// No route, just use legacy page id syntax.
if (url.IsNullOrWhiteSpace())
{
url = $"/page/{confirmationPage.Id}";
}
// If they didn't provide a base url, then use the one for the page.
if (baseUrl.IsNullOrWhiteSpace())
{
baseUrl = confirmationPage.Layout.Site.DefaultDomainUri.AbsoluteUri;
}
var confirmAccountUrl = baseUrl.TrimEnd('/') + "/" + url.TrimStart('/');
// Duplicate the merge fields so we don't corrupt the original
// dictionary.
mergeFields = mergeFields != null ? new Dictionary <string, object>(mergeFields) : new Dictionary <string, object>();
mergeFields.AddOrReplace("ConfirmAccountUrl", confirmAccountUrl);
mergeFields.AddOrReplace("Person", userLogin.Person);
mergeFields.AddOrReplace("User", userLogin);
// Send the e-mail to the on-file address for the person.
var recipients = new List <RockEmailMessageRecipient>
{
new RockEmailMessageRecipient(userLogin.Person, mergeFields)
};
// Send it off.
var message = new RockEmailMessage(systemEmailGuid);
message.SetRecipients(recipients);
message.AppRoot = "/";
message.ThemeRoot = $"/Themes/{confirmationPage.Layout.Site.Theme}";
message.CreateCommunicationRecord = false;
message.Send();
}
/// <summary>
/// Displays the sent login.
/// </summary>
/// <param name="direction">The direction.</param>
private void DisplaySentLogin(Direction direction)
{
var rockContext = new RockContext();
PersonService personService = new PersonService(rockContext);
Person person = personService.Get(hfSendPersonId.Value.AsInteger());
if (person != null)
{
string url = LinkedPageUrl(AttributeKey.ConfirmationPage);
if (string.IsNullOrWhiteSpace(url))
{
url = ResolveRockUrl("~/ConfirmAccount");
}
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
mergeObjects.Add("ConfirmAccountUrl", RootPath + url.TrimStart(new char[] { '/' }));
var results = new List <IDictionary <string, object> >();
var users = new List <UserLogin>();
var userLoginService = new UserLoginService(rockContext);
foreach (UserLogin user in userLoginService.GetByPersonId(person.Id))
{
if (user.EntityType != null)
{
var component = AuthenticationContainer.GetComponent(user.EntityType.Name);
if (component.ServiceType == AuthenticationServiceType.Internal)
{
users.Add(user);
}
}
}
var resultsDictionary = new Dictionary <string, object>();
resultsDictionary.Add("Person", person);
resultsDictionary.Add("Users", users);
results.Add(resultsDictionary);
mergeObjects.Add("Results", results.ToArray());
var emailMessage = new RockEmailMessage(GetAttributeValue(AttributeKey.ForgotUsernameTemplate).AsGuid());
emailMessage.AddRecipient(new RockEmailMessageRecipient(person, mergeObjects));
emailMessage.AppRoot = ResolveRockUrl("~/");
emailMessage.ThemeRoot = ResolveRockUrl("~~/");
emailMessage.CreateCommunicationRecord = false;
emailMessage.Send();
}
else
{
ShowErrorMessage("Invalid Person");
}
ShowPanel(3);
}
/// <summary>
/// Sends the specified recipients.
/// </summary>
/// <param name="recipients">The recipients.</param>
/// <param name="fromEmail">From email.</param>
/// <param name="fromName">From name.</param>
/// <param name="subject">The subject.</param>
/// <param name="body">The body.</param>
/// <param name="createCommunicationRecord">if set to <c>true</c> [create communication record].</param>
/// <param name="metaData">The meta data.</param>
private void Send(List <RockEmailMessageRecipient> recipients, string fromEmail, string fromName, string subject, string body, bool createCommunicationRecord, Dictionary <string, string> metaData)
{
var emailMessage = new RockEmailMessage();
emailMessage.SetRecipients(recipients);
emailMessage.FromEmail = fromEmail;
emailMessage.FromName = fromName;
emailMessage.Subject = subject;
emailMessage.Message = body;
emailMessage.CreateCommunicationRecord = createCommunicationRecord;
emailMessage.MessageMetaData = metaData;
emailMessage.Send();
}
/// <summary>
/// Checks the integrity of the database
/// </summary>
/// <param name="commandTimeout">The command timeout.</param>
/// <param name="alertEmail">The alert email.</param>
/// <returns></returns>
private bool IntegrityCheck(int commandTimeout, string alertEmail)
{
string databaseName = new RockContext().Database.Connection.Database;
string integrityQuery = $"DBCC CHECKDB('{ databaseName }',NOINDEX) WITH PHYSICAL_ONLY, NO_INFOMSGS";
bool checkPassed = true;
Stopwatch stopwatch = Stopwatch.StartNew();
// DBCC CHECKDB will return a count of how many issues there were
int integrityErrorCount = DbService.ExecuteCommand(integrityQuery, System.Data.CommandType.Text, null, commandTimeout);
stopwatch.Stop();
var databaseMaintenanceTaskResult = new DatabaseMaintenanceTaskResult
{
Title = "Integrity Check",
Elapsed = stopwatch.Elapsed
};
_databaseMaintenanceTaskResults.Add(databaseMaintenanceTaskResult);
if (integrityErrorCount > 0)
{
// oh no...
checkPassed = false;
string errorMessage = $"Some errors were reported when running a database integrity check on your Rock database. We'd recommend running the command below under 'Admin Tools > Power Tools > SQL Command' to get further details. <p>DBCC CHECKDB ('{ databaseName }') WITH NO_INFOMSGS, ALL_ERRORMSGS</p>";
var mergeFields = Lava.LavaHelper.GetCommonMergeFields(null, null);
mergeFields.Add("ErrorMessage", errorMessage);
mergeFields.Add("Errors", integrityErrorCount);
databaseMaintenanceTaskResult.Exception = new Exception(errorMessage);
if (alertEmail.IsNotNullOrWhiteSpace())
{
var globalAttributes = GlobalAttributesCache.Get();
string emailHeader = globalAttributes.GetValue("EmailHeader");
string emailFooter = globalAttributes.GetValue("EmailFooter");
string messageBody = $"{emailHeader} {errorMessage} <p><small>This message was generated from the Rock Database Maintenance Job</small></p>{emailFooter}";
var emailMessage = new RockEmailMessage();
var alertEmailList = alertEmail.Split(',').ToList();
var recipients = alertEmailList.Select(a => RockEmailMessageRecipient.CreateAnonymous(a, mergeFields)).ToList();
emailMessage.Subject = "Rock: Database Integrity Check Error";
emailMessage.Message = messageBody;
emailMessage.Send();
}
}
return(checkPassed);
}
/// <summary>
/// Executes this instance.
/// </summary>
/// <param name="message"></param>
public override void Execute(Message message)
{
using (var rockContext = new RockContext())
{
var communication = new CommunicationService(rockContext).Get(message.CommunicationId);
if (communication != null && communication.Status == CommunicationStatus.PendingApproval)
{
// get notification group
var groupGuid = SystemGuid.Group.GROUP_COMMUNICATION_APPROVERS.AsGuid();
var approvers = new GroupMemberService(rockContext).Queryable()
.Where(m =>
m.Group.Guid == groupGuid &&
m.GroupMemberStatus == GroupMemberStatus.Active)
.ToList();
if (approvers.Any())
{
var communicationSettingApprovalGuid = Rock.Web.SystemSettings.GetValue(SystemSetting.COMMUNICATION_SETTING_APPROVAL_TEMPLATE).AsGuidOrNull();
if (communicationSettingApprovalGuid.HasValue)
{
var approvalPageUrl = message.ApprovalPageUrl;
// create approval link if one was not provided
if (string.IsNullOrEmpty(approvalPageUrl))
{
var internalApplicationRoot = GlobalAttributesCache.Value("InternalApplicationRoot").EnsureTrailingForwardslash();
approvalPageUrl = $"{internalApplicationRoot}Communication/{communication.Id}";
}
foreach (var approver in approvers)
{
var recipients = new List <RockEmailMessageRecipient>();
var emailMessage = new RockEmailMessage(communicationSettingApprovalGuid.Value);
// Build Lava merge fields.
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
mergeFields.Add("Approver", approver.Person);
mergeFields.Add("Communication", communication);
mergeFields.Add("RecipientsCount", communication.GetRecipientsQry(rockContext).Count());
mergeFields.Add("ApprovalPageUrl", approvalPageUrl);
recipients.Add(new RockEmailMessageRecipient(approver.Person, mergeFields));
emailMessage.SetRecipients(recipients);
emailMessage.Send();
}
}
}
}
}
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public virtual void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
int alertPeriod = dataMap.GetInt("AlertPeriod");
Guid? systemEmailGuid = dataMap.GetString("AlertEmail").AsGuidOrNull();
List <string> recipientEmails = dataMap.GetString("AlertRecipients").SplitDelimitedValues().ToList();
if (systemEmailGuid.HasValue && recipientEmails.Any())
{
var rockContext = new RockContext();
int expirationDays = GetJobAttributeValue("ExpirationPeriod", 3, rockContext);
var beginWindow = RockDateTime.Now.AddDays(0 - expirationDays);
var cutoffTime = RockDateTime.Now.AddMinutes(0 - alertPeriod);
var communications = new CommunicationService(rockContext)
.GetQueued(expirationDays, alertPeriod, false, false)
.NotRecentlyApproved(cutoffTime)
.IfScheduledAreInWindow(beginWindow, cutoffTime)
.OrderBy(c => c.Id)
.ToList();
if (communications.Any())
{
var mergeFields = Lava.LavaHelper.GetCommonMergeFields(null);
mergeFields.Add("Communications", communications);
var emailMessage = new RockEmailMessage(systemEmailGuid.Value);
foreach (var email in recipientEmails)
{
emailMessage.AddRecipient(RockEmailMessageRecipient.CreateAnonymous(email, mergeFields));
}
var errors = new List <string>();
emailMessage.Send(out errors);
context.Result = string.Format("Notified about {0} queued communications. {1} errors encountered.", communications.Count, errors.Count);
if (errors.Any())
{
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.Append("Errors: ");
errors.ForEach(e => { sb.AppendLine(); sb.Append(e); });
string errorMessage = sb.ToString();
context.Result += errorMessage;
throw new Exception(errorMessage);
}
}
}
}
private void Send(string recipients, string fromEmail, string fromName, string subject, string body, Dictionary <string, object> mergeFields, RockContext rockContext, bool createCommunicationRecord)
{
var emailMessage = new RockEmailMessage();
foreach (string recipient in recipients.SplitDelimitedValues().ToList())
{
emailMessage.AddRecipient(new RecipientData(recipient, mergeFields));
}
emailMessage.FromEmail = fromEmail;
emailMessage.FromName = fromName;
emailMessage.Subject = subject;
emailMessage.Message = body;
emailMessage.CreateCommunicationRecord = createCommunicationRecord;
emailMessage.Send();
}
private void SendReceipt()
{
RockContext rockContext = new RockContext();
var receiptEmail = new SystemEmailService(rockContext).Get(new Guid(GetAttributeValue("ReceiptEmail")));
if (receiptEmail != null)
{
var givingUnit = new PersonAliasService(rockContext).Get(this.SelectedGivingUnit.PersonAliasId).Person;
var emailMessage = new RockEmailMessage(receiptEmail.Guid);
emailMessage.AddRecipient(new RecipientData(givingUnit.Email, GetMergeFields(givingUnit)));
emailMessage.AppRoot = ResolveRockUrl("~/");
emailMessage.ThemeRoot = ResolveRockUrl("~~/");
emailMessage.Send();
}
}
/// <summary>
/// Sends the new group member an email using the group attributes
/// </summary>
/// <returns>true if settings are valid; false otherwise</returns>
protected void SendGroupEmail(GroupMember groupMember)
{
var group = groupMember.Group;
if (group.Attributes == null)
{
group.LoadAttributes();
}
var sendEmail = group.GetAttributeValue("SendEmail").AsBoolean();
if (sendEmail && !string.IsNullOrWhiteSpace(groupMember.Person.Email))
{
var message = group.GetAttributeValue("Message");
if (!string.IsNullOrWhiteSpace(message))
{
var mergeFields = new Dictionary <string, object>()
{
{ "Group", group },
{ "GroupMember", groupMember },
{ "Person", groupMember.Person }
};
var fromEmail = group.GetAttributeValue("FromEmail");
var fromName = group.GetAttributeValue("FromName");
var subject = group.GetAttributeValue("Subject");
var emailMessage = new RockEmailMessage();
emailMessage.AddRecipient(new RecipientData(groupMember.Person.Email, mergeFields));
emailMessage.FromEmail = fromEmail;
emailMessage.FromName = fromName;
emailMessage.Subject = subject;
emailMessage.Message = message;
emailMessage.CreateCommunicationRecord = true;
emailMessage.AppRoot = Rock.Web.Cache.GlobalAttributesCache.Get().GetValue("InternalApplicationRoot") ?? string.Empty;
emailMessage.Send();
}
}
}
private void SendNotificationEmail(List <TestResult> alarms, List <Person> people)
{
var systemCommunication = dataMap.GetString("NotificationCommunication").AsGuid();
var emailMessage = new RockEmailMessage(systemCommunication);
var recipients = new List <RockMessageRecipient>();
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null, null);
mergeFields.Add("Alarms", alarms);
foreach (var person in people)
{
recipients.Add(new RockEmailMessageRecipient(person, mergeFields));
}
emailMessage.SetRecipients(recipients);
emailMessage.CreateCommunicationRecord = true;
emailMessage.Send();
}
private void SendEmailToMember(GroupMember member, Group group, KeyValuePair <int, List <DateTime> > occGroup)
{
var email = staffEmail;
if (member.IsNotNull())
{
email = member.Person.Email;
}
if (email.IsNotNullOrWhiteSpace())
{
groupsNotified.Add(group.Id);
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(null, member.IsNotNull() ? member.Person : null);
mergeObjects.Add("Person", member.IsNotNull() ? member.Person : null);
mergeObjects.Add("Group", group);
mergeObjects.Add("Occurrence", occGroup.Value.Max());
var recipients = new List <RockEmailMessageRecipient>();
recipients.Add(RockEmailMessageRecipient.CreateAnonymous(email, mergeObjects));
var emailMessage = new RockEmailMessage(systemEmailGuid);
emailMessage.SetRecipients(recipients);
var errors = new List <string>();
emailMessage.Send(out errors);
if (errors.Any())
{
errorCount += errors.Count;
errorMessages.AddRange(errors);
}
else
{
attendanceRemindersSent++;
}
}
else
{
errorCount += 1;
errorMessages.Add(string.Format("No email specified for group {0} and no fallback email provided.", group.Id));
}
}
private List <string> SendReminderEmail(Guid assessmentSystemEmailGuid, int PersonAliasId)
{
var person = new PersonAliasService(new RockContext()).GetPerson(PersonAliasId);
var mergeObjects = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
mergeObjects.Add("Person", person);
var recipients = new List <RecipientData>();
recipients.Add(new RecipientData(person.Email, mergeObjects));
var errors = new List <string>();
var emailMessage = new RockEmailMessage(assessmentSystemEmailGuid);
emailMessage.SetRecipients(recipients);
emailMessage.Send(out errors);
return(errors);
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public virtual void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
var emailTemplateGuid = dataMap.Get("SystemEmail").ToString().AsGuid();
var groupGuid = dataMap.Get("Group").ToString().AsGuid();
var sendToDescendants = dataMap.Get("SendToDescendantGroups").ToString().AsBoolean();
var rockContext = new RockContext();
var group = new GroupService(rockContext).Get(groupGuid);
if (group != null)
{
List <int> groupIds = new List <int>();
GetGroupIds(groupIds, sendToDescendants, group);
var recipients = new List <RecipientData>();
var groupMemberList = new GroupMemberService(rockContext).Queryable().Where(gm =>
groupIds.Contains(gm.GroupId) &&
gm.GroupMemberStatus == GroupMemberStatus.Active)
.ToList();
foreach (GroupMember groupMember in groupMemberList)
{
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
mergeFields.Add("Person", groupMember.Person);
mergeFields.Add("GroupMember", groupMember);
mergeFields.Add("Group", groupMember.Group);
recipients.Add(new RecipientData(groupMember.Person.Email, mergeFields));
}
if (recipients.Any())
{
var emailMessage = new RockEmailMessage(emailTemplateGuid);
emailMessage.SetRecipients(recipients);
emailMessage.Send();
}
context.Result = string.Format("{0} emails sent", recipients.Count());
}
}
/// <summary>
/// Sends and individual digest email to the specified person.
/// </summary>
/// <param name="systemCommunication">The system communication.</param>
/// <param name="mergeObjects">The Lava merge objects.</param>
/// <param name="person">The person who should receive the email.</param>
/// <param name="regionalGroup">The regional group that this digest email represents.</param>
private void SendDigestEmail(SystemCommunication systemCommunication, Dictionary <string, object> mergeObjects, Person person, Group regionalGroup)
{
mergeObjects.AddOrReplace("Person", person);
var recipient = new RockEmailMessageRecipient(person, mergeObjects);
var message = new RockEmailMessage(systemCommunication);
message.Subject = $"'{regionalGroup.Name}' Group Attendance Digest";
message.SetRecipients(new List <RockEmailMessageRecipient> {
recipient
});
message.Send(out List <string> errorMessages);
if (!errorMessages.Any())
{
_digestsSentCount++;
return;
}
_errors.Add($"Unable to send '{regionalGroup.Name}' digest to '{person.Email}'.");
}
/// <summary>
/// Sends the confirmation email.
/// </summary>
/// <param name="attendance">The attendance.</param>
/// <param name="recipientEmailAddresses">The recipient email addresses.</param>
private void SendResponseEmail(Attendance attendance, List <string> recipientEmailAddresses)
{
try
{
var mergeFields = MergeFields(attendance);
// Distinct is used so that if the same email address is for both the Scheduler and ScheduleCancellationPersonAlias
// Only one email will be sent
foreach (var recipient in recipientEmailAddresses.Distinct(StringComparer.CurrentCultureIgnoreCase).Where(s => s.IsNotNullOrWhiteSpace()))
{
var emailMessage = new RockEmailMessage(GetAttributeValue("SchedulingResponseEmail").AsGuid());
emailMessage.AddRecipient(new RecipientData(recipient, mergeFields));
emailMessage.CreateCommunicationRecord = false;
emailMessage.Send();
}
}
catch (SystemException ex)
{
ExceptionLogService.LogException(ex, Context, RockPage.PageId, RockPage.Site.Id, CurrentPersonAlias);
}
}
/// <summary>
/// Sends the confirmation email.
/// </summary>
/// <param name="attendance">The attendance.</param>
/// <param name="recipientEmailAddresses">The recipient email addresses.</param>
private void SendResponseEmail(Attendance attendance, List <RockEmailMessageRecipient> recipients)
{
try
{
var mergeFields = MergeFields(attendance);
// Distinct is used so that if the same email address is for both the Scheduler and ScheduleCancellationPersonAlias
// Only one email will be sent
foreach (var recipient in recipients)
{
recipient.MergeFields = mergeFields;
var emailMessage = new RockEmailMessage(GetAttributeValue("SchedulingResponseEmail").AsGuid());
emailMessage.AddRecipient(recipient);
emailMessage.CreateCommunicationRecord = false;
emailMessage.Send();
}
}
catch (SystemException ex)
{
ExceptionLogService.LogException(ex, Context, RockPage.PageId, RockPage.Site.Id, CurrentPersonAlias);
}
}