/// <summary> /// Set the note as Watched or Unwatched by the current person /// </summary> /// <param name="noteId">The note identifier.</param> /// <param name="watching">if set to <c>true</c> [watching].</param> private void WatchNote(int?noteId, bool watching) { var rockPage = this.Page as RockPage; if (rockPage != null) { var currentPerson = rockPage.CurrentPerson; var rockContext = new RockContext(); var noteService = new NoteService(rockContext); var noteWatchService = new NoteWatchService(rockContext); if (noteId.HasValue) { var note = noteService.Get(noteId.Value); if (note != null && note.IsAuthorized(Authorization.VIEW, currentPerson)) { var noteWatch = noteWatchService.Queryable().Where(a => a.NoteId == noteId.Value && a.WatcherPersonAlias.PersonId == currentPerson.Id).FirstOrDefault(); if (noteWatch == null) { noteWatch = new NoteWatch { NoteId = noteId.Value, WatcherPersonAliasId = rockPage.CurrentPersonAliasId }; noteWatchService.Add(noteWatch); } noteWatch.IsWatching = watching; rockContext.SaveChanges(); } } } }
/// <summary> /// Binds the grid. /// </summary> private void BindGrid() { RockContext rockContext = new RockContext(); NoteWatchService noteWatchService = new NoteWatchService(rockContext); var qry = noteWatchService.Queryable().Include(a => a.WatcherPersonAlias.Person).Include(a => a.WatcherGroup); Guid?blockEntityTypeGuid = this.GetAttributeValue("EntityType").AsGuidOrNull(); Guid?blockNoteTypeGuid = this.GetAttributeValue("NoteType").AsGuidOrNull(); if (blockNoteTypeGuid.HasValue) { // if a NoteType was specified in block settings, only list note watches for the specified note type int noteTypeId = EntityTypeCache.Get(blockNoteTypeGuid.Value).Id; qry = qry.Where(a => a.NoteTypeId.HasValue && a.NoteTypeId == noteTypeId); } else if (blockEntityTypeGuid.HasValue) { // if an EntityType was specific in block settings, only list note watches for the specified entity type (or for NoteTypes of the specified EntityType) int entityTypeId = EntityTypeCache.Get(blockEntityTypeGuid.Value).Id; qry = qry.Where(a => (a.EntityTypeId.HasValue && a.EntityTypeId.Value == entityTypeId) || (a.NoteTypeId.HasValue && a.NoteType.EntityTypeId == entityTypeId)); } var contextPerson = ContextEntity <Person>(); var contextGroup = ContextEntity <Group>(); if (contextPerson != null) { // if there is a Person context, only list note watches that where the watcher is the person context qry = qry.Where(a => a.WatcherPersonAliasId.HasValue && a.WatcherPersonAlias.PersonId == contextPerson.Id); } else if (contextGroup != null) { // if there is a Group context, only list note watches that where the watcher is the group context qry = qry.Where(a => a.WatcherGroupId.HasValue && a.WatcherGroupId == contextGroup.Id); } var sortProperty = gList.SortProperty; if (sortProperty != null) { qry = qry.Sort(sortProperty); } else { qry = qry.OrderBy(d => d.EntityType.Name).ThenBy(a => a.NoteType.Name); } gList.SetLinqDataSource(qry); gList.DataBind(); }
/// <summary> /// Handles the Delete event of the gList control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="RowEventArgs"/> instance containing the event data.</param> protected void gList_Delete(object sender, RowEventArgs e) { var rockContext = new RockContext(); var service = new NoteWatchService(rockContext); var noteWatch = service.Get(e.RowKeyId); if (noteWatch != null) { string errorMessage; if (!service.CanDelete(noteWatch, out errorMessage)) { mdGridWarning.Show(errorMessage, ModalAlertType.Information); return; } service.Delete(noteWatch); rockContext.SaveChanges(); } BindGrid(); }
/// <summary> /// Sends the note watch notifications. /// </summary> /// <param name="context">The context.</param> private List <string> SendNoteWatchNotifications(IJobExecutionContext context) { var errors = new List <string>(); List <int> noteIdsToProcessNoteWatchesList = new List <int>(); using (var rockContext = new RockContext()) { var noteService = new NoteService(rockContext); var noteWatchService = new NoteWatchService(rockContext); var noteWatchQuery = noteWatchService.Queryable(); if (!noteWatchQuery.Any()) { // there aren't any note watches, so there is nothing to do return(errors); } // get all notes that haven't processed notifications yet var notesToNotifyQuery = noteService.Queryable().Where(a => a.NotificationsSent == false && a.NoteType.AllowsWatching == true && a.EditedDateTime > _cutoffNoteEditDateTime); // limit to notes that don't require approval or are approved notesToNotifyQuery = notesToNotifyQuery.Where(a => a.NoteType.RequiresApprovals == false || a.ApprovalStatus == NoteApprovalStatus.Approved); if (!notesToNotifyQuery.Any()) { // there aren't any notes that haven't had notifications processed yet return(errors); } noteIdsToProcessNoteWatchesList = notesToNotifyQuery.Select(a => a.Id).ToList(); } // make a list of notifications to send to each personId Dictionary <int, NoteWatchPersonToNotifyList> personNotificationDigestList = new Dictionary <int, NoteWatchPersonToNotifyList>(); using (var rockContext = new RockContext()) { foreach (int noteId in noteIdsToProcessNoteWatchesList) { this.UpdateNoteWatchNotificationDigest(personNotificationDigestList, rockContext, noteId); } // Send NoteWatch notifications if (personNotificationDigestList.Any()) { foreach (var personNotificationDigest in personNotificationDigestList) { var recipients = new List <RecipientData>(); Person personToNotify = personNotificationDigest.Value.Person; List <Note> noteList = personNotificationDigest.Value.Select(a => a.Note).OrderBy(a => a.EditedDateTime).ToList(); // make sure a person doesn't get a notification on a note that they wrote noteList = noteList.Where(a => a.EditedByPersonAlias?.PersonId != personToNotify.Id).ToList(); if (!string.IsNullOrEmpty(personToNotify.Email) && personToNotify.IsEmailActive && personToNotify.EmailPreference != EmailPreference.DoNotEmail && noteList.Any()) { var mergeFields = new Dictionary <string, object>(_defaultMergeFields); mergeFields.Add("Person", personToNotify); mergeFields.Add("NoteList", noteList); recipients.Add(new RecipientData(personToNotify.Email, mergeFields)); } if (_noteWatchNotificationEmailGuid.HasValue) { var emailMessage = new RockEmailMessage(_noteWatchNotificationEmailGuid.Value); emailMessage.SetRecipients(recipients); emailMessage.Send(out errors); _noteWatchNotificationsSent += recipients.Count(); } } } } using (var rockUpdateContext = new RockContext()) { var notesToMarkNotified = new NoteService(rockUpdateContext).Queryable().Where(a => noteIdsToProcessNoteWatchesList.Contains(a.Id)); // use BulkUpdate to mark all the notes that we processed to NotificationsSent = true rockUpdateContext.BulkUpdate(notesToMarkNotified, n => new Note { NotificationsSent = true }); } return(errors); }
/// <summary> /// Shows the detail. /// </summary> /// <param name="noteWatchId">The note watch identifier.</param> public void ShowDetail(int noteWatchId) { pnlView.Visible = true; var rockContext = new RockContext(); // Load depending on Add(0) or Edit NoteWatch noteWatch = null; if (noteWatchId > 0) { noteWatch = new NoteWatchService(rockContext).Get(noteWatchId); lActionTitle.Text = ActionTitle.Edit(NoteWatch.FriendlyTypeName).FormatAsHtmlTitle(); pdAuditDetails.SetEntity(noteWatch, ResolveRockUrl("~")); } pdAuditDetails.Visible = noteWatch != null; var contextPerson = ContextEntity <Person>(); var contextGroup = ContextEntity <Group>(); if (noteWatch == null) { noteWatch = new NoteWatch { Id = 0 }; lActionTitle.Text = ActionTitle.Add(NoteWatch.FriendlyTypeName).FormatAsHtmlTitle(); if (contextPerson != null) { noteWatch.WatcherPersonAliasId = contextPerson.PrimaryAliasId; noteWatch.WatcherPersonAlias = contextPerson.PrimaryAlias; } else if (contextGroup != null) { noteWatch.WatcherGroupId = contextGroup.Id; noteWatch.WatcherGroup = contextGroup; } } if (contextPerson != null) { ppWatcherPerson.Enabled = false; gpWatcherGroup.Visible = false; // make sure we are seeing details for a NoteWatch that the current person is watching if (!noteWatch.WatcherPersonAliasId.HasValue || !contextPerson.Aliases.Any(a => a.Id == noteWatch.WatcherPersonAliasId.Value)) { // The NoteWatchId in the url isn't a NoteWatch for the PersonContext, so just hide the block pnlView.Visible = false; } } else if (contextGroup != null) { ppWatcherPerson.Visible = false; gpWatcherGroup.Enabled = false; // make sure we are seeing details for a NoteWatch that the current group context is watching if (!noteWatch.WatcherGroupId.HasValue || !(contextGroup.Id != noteWatch.WatcherGroupId)) { // The NoteWatchId in the url isn't a NoteWatch for the GroupContext, so just hide the block pnlView.Visible = false; } } hfNoteWatchId.Value = noteWatchId.ToString(); etpEntityType.SetValue(noteWatch.EntityTypeId); LoadNoteTypeDropDown(noteWatch.EntityTypeId); ddlNoteType.SetValue(noteWatch.NoteTypeId); if (noteWatch.WatcherPersonAlias != null) { ppWatcherPerson.SetValue(noteWatch.WatcherPersonAlias.Person); } else { ppWatcherPerson.SetValue(( Person )null); } gpWatcherGroup.SetValue(noteWatch.WatcherGroup); cbIsWatching.Checked = noteWatch.IsWatching; cbIsWatching_CheckedChanged(null, null); cbAllowOverride.Checked = noteWatch.AllowOverride; ShowEntityPicker(etpEntityType.SelectedEntityTypeId); etpEntityType.Enabled = true; if (noteWatch.EntityTypeId.HasValue && noteWatch.EntityId.HasValue) { var watchedEntityTypeId = noteWatch.EntityTypeId; IEntity watchedEntity = new EntityTypeService(rockContext).GetEntity(noteWatch.EntityTypeId.Value, noteWatch.EntityId.Value); if (watchedEntity != null) { if (watchedEntity is Rock.Model.Person) { ppWatchedPerson.SetValue(watchedEntity as Rock.Model.Person); } else if (watchedEntity is Rock.Model.Group) { gpWatchedGroup.SetValue(watchedEntity as Rock.Model.Group); } else { lWatchedEntityName.Text = watchedEntity.ToString(); nbWatchedEntityId.Text = watchedEntity.Id.ToString(); } // Don't let the EntityType get changed if there is a specific Entity getting watched etpEntityType.Enabled = false; } } lWatchedNote.Visible = false; if (noteWatch.Note != null) { var mergefields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, null, new Rock.Lava.CommonMergeFieldsOptions { GetLegacyGlobalMergeFields = false }); mergefields.Add("Note", noteWatch.Note); var lavaTemplate = this.GetAttributeValue("WatchedNoteLavaTemplate"); lWatchedNote.Text = lavaTemplate.ResolveMergeFields(mergefields); } }
/// <summary> /// Handles the Click event of the btnSave 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 btnSave_Click(object sender, EventArgs e) { NoteWatch noteWatch; var rockContext = new RockContext(); var noteWatchService = new NoteWatchService(rockContext); var noteWatchId = hfNoteWatchId.Value.AsInteger(); if (noteWatchId == 0) { noteWatch = new NoteWatch(); noteWatchService.Add(noteWatch); } else { noteWatch = noteWatchService.Get(noteWatchId); } noteWatch.NoteTypeId = ddlNoteType.SelectedValue.AsIntegerOrNull(); noteWatch.EntityTypeId = etpEntityType.SelectedEntityTypeId; if (noteWatch.EntityTypeId.HasValue) { if (noteWatch.EntityTypeId.Value == EntityTypeCache.GetId <Rock.Model.Person>()) { noteWatch.EntityId = ppWatchedPerson.PersonId; } else if (noteWatch.EntityTypeId.Value == EntityTypeCache.GetId <Rock.Model.Group>()) { noteWatch.EntityId = gpWatchedGroup.GroupId; } else { noteWatch.EntityId = nbWatchedEntityId.Text.AsIntegerOrNull(); } } noteWatch.WatcherPersonAliasId = ppWatcherPerson.PersonAliasId; noteWatch.WatcherGroupId = gpWatcherGroup.GroupId; noteWatch.IsWatching = cbIsWatching.Checked; noteWatch.AllowOverride = cbAllowOverride.Checked; // see if the Watcher parameters are valid if (!noteWatch.IsValidWatcher) { nbWatcherMustBeSelectWarning.Visible = true; return; } // see if the Watch filters parameters are valid if (!noteWatch.IsValidWatchFilter) { nbWatchFilterMustBeSeletedWarning.Visible = true; return; } if (!noteWatch.IsValid) { return; } // See if there is a matching filter that doesn't allow overrides if (noteWatch.IsWatching == false) { if (!noteWatch.IsAbleToUnWatch(rockContext)) { var nonOverridableNoteWatch = noteWatch.GetNonOverridableNoteWatches(rockContext).FirstOrDefault(); if (nonOverridableNoteWatch != null) { string otherNoteWatchLink; if (nonOverridableNoteWatch.IsAuthorized(Rock.Security.Authorization.VIEW, this.CurrentPerson)) { var otherNoteWatchWatchPageReference = new Rock.Web.PageReference(this.CurrentPageReference); otherNoteWatchWatchPageReference.QueryString = new System.Collections.Specialized.NameValueCollection(otherNoteWatchWatchPageReference.QueryString); otherNoteWatchWatchPageReference.QueryString["NoteWatchId"] = nonOverridableNoteWatch.Id.ToString(); otherNoteWatchLink = string.Format("<a href='{0}'>note watch</a>", otherNoteWatchWatchPageReference.BuildUrl()); } else { otherNoteWatchLink = "note watch"; } nbUnableToOverride.Text = string.Format( "Unable to set Watching to false. This would override another {0} that doesn't allow overrides.", otherNoteWatchLink); nbUnableToOverride.Visible = true; return; } } } // see if the NoteType allows following if (noteWatch.NoteTypeId.HasValue) { var noteTypeCache = NoteTypeCache.Get(noteWatch.NoteTypeId.Value); if (noteTypeCache != null) { if (noteTypeCache.AllowsWatching == false) { nbNoteTypeWarning.Visible = true; return; } } } rockContext.SaveChanges(); NavigateToNoteWatchParentPage(); }