/// <summary>
/// Handles the Click event of the lbAddNote 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 lbAddNote_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
var service = new NoteService( rockContext );
var note = new Note();
note.IsSystem = false;
note.IsAlert = false;
note.NoteTypeId = noteType.Id;
note.EntityId = contextEntity.Id;
note.Text = tbNewNote.Text;
if ( noteType.Sources != null )
{
var source = noteType.Sources.DefinedValues.FirstOrDefault();
if ( source != null )
{
note.SourceTypeValueId = source.Id;
}
}
service.Add( note );
rockContext.SaveChanges();
ShowNotes();
}
/// <summary>
/// Renders the specified writer.
/// </summary>
/// <param name="badge">The badge.</param>
/// <param name="writer">The writer.</param>
public override void Render( PersonBadgeCache badge, System.Web.UI.HtmlTextWriter writer )
{
List<Guid> noteTypes = new List<Guid>();
if ( !string.IsNullOrEmpty( GetAttributeValue( badge, "NoteTypes" ) ) )
{
noteTypes = Array.ConvertAll( GetAttributeValue( badge, "NoteTypes" ).Split( ',' ), s => new Guid( s ) ).ToList();
}
var currentUser = UserLoginService.GetCurrentUser();
int? currentPersonId = currentUser != null ? currentUser.PersonId : null;
// check for alert note
var alertNotesExist = new NoteService( new RockContext() ).Queryable().AsNoTracking()
.Where( n => noteTypes.Contains( n.NoteType.Guid )
&& n.EntityId.Value == Person.Id
&& n.IsAlert == true
&& ( !n.IsPrivateNote || n.CreatedByPersonAlias.PersonId == currentPersonId )
)
.Any();
if ( alertNotesExist )
{
writer.Write( GetAttributeValue( badge, "BadgeContent" ) );
}
}
/// <summary>
/// Shows the detail.
/// </summary>
/// <param name="restUserId">The rest user identifier.</param>
public void ShowDetail( int restUserId )
{
var rockContext = new RockContext();
Person restUser = null;
if ( !restUserId.Equals( 0 ) )
{
restUser = new PersonService( rockContext ).Get( restUserId );
}
if ( restUser == null )
{
restUser = new Person { Id = 0 };
}
bool editAllowed = restUser.IsAuthorized( Authorization.EDIT, CurrentPerson );
hfRestUserId.Value = restUser.Id.ToString();
lTitle.Text = ActionTitle.Edit( "REST Key" ).FormatAsHtmlTitle();
if ( restUser.Id > 0 )
{
tbName.Text = restUser.LastName;
cbActive.Checked = false;
var activeStatusId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid() ).Id;
if ( restUser.RecordStatusValueId == activeStatusId )
{
cbActive.Checked = true;
}
var noteService = new NoteService( rockContext );
var description = noteService.Queryable().Where( a => a.EntityId == restUser.Id ).FirstOrDefault();
if ( description != null )
{
tbDescription.Text = description.Text;
}
var userLoginService = new UserLoginService( rockContext );
var userLogin = userLoginService.Queryable().Where( a => a.PersonId == restUser.Id ).FirstOrDefault();
if ( userLogin != null )
{
tbKey.Text = userLogin.ApiKey;
}
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute( RockContext rockContext, WorkflowAction action, Object entity, out List<string> errorMessages )
{
errorMessages = new List<string>();
var person = GetPersonAliasFromActionAttribute("Person", rockContext, action, errorMessages);
if (person != null)
{
var mergeFields = GetMergeFields(action);
NoteService noteService = new NoteService(rockContext);
Note note = new Note();
note.EntityId = person.Id;
note.Caption = GetAttributeValue( action, "Caption" ).ResolveMergeFields(mergeFields);
note.IsAlert = GetAttributeValue(action, "Alert").AsBoolean();
note.IsPrivateNote = false;
note.Text = GetAttributeValue(action, "Text").ResolveMergeFields(mergeFields); ;
var noteType = NoteTypeCache.Read( GetAttributeValue( action, "NoteType" ).AsGuid() );
if ( noteType != null )
{
note.NoteTypeId = noteType.Id;
}
// get author
var author = GetPersonAliasFromActionAttribute("Author", rockContext, action, errorMessages);
if (author != null)
{
note.CreatedByPersonAliasId = author.PrimaryAlias.Id;
}
noteService.Add(note);
rockContext.SaveChanges();
return true;
}
else
{
errorMessages.Add("No person was provided for the note.");
}
errorMessages.ForEach( m => action.AddLogEntry( m, true ) );
return true;
}
/// <summary>
/// Handles the RowDataBound event of the gRestKeyList control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="GridViewRowEventArgs"/> instance containing the event data.</param>
protected void gRestKeyList_RowDataBound( object sender, GridViewRowEventArgs e )
{
if ( e.Row.RowType == DataControlRowType.DataRow )
{
var rockContext = new RockContext();
var restUser = e.Row.DataItem as Person;
var noteService = new NoteService( rockContext );
var description = noteService.Queryable().Where( a => a.EntityId == restUser.Id ).FirstOrDefault();
Label lblDescription = e.Row.FindControl( "lblDescription" ) as Label;
if ( description != null )
{
lblDescription.Text = description.Text;
}
var userLoginService = new UserLoginService( rockContext );
var userLogin = userLoginService.Queryable().Where( a => a.PersonId == restUser.Id ).FirstOrDefault();
Label lblKey = e.Row.FindControl( "lblKey" ) as Label;
if ( userLogin != null )
{
lblKey.Text = userLogin.ApiKey;
}
}
}
private void SaveScheduledTransaction( FinancialGateway financialGateway, GatewayComponent gateway, Person person, PaymentInfo paymentInfo, PaymentSchedule schedule, FinancialScheduledTransaction scheduledTransaction, RockContext rockContext )
{
scheduledTransaction.TransactionFrequencyValueId = schedule.TransactionFrequencyValue.Id;
scheduledTransaction.StartDate = schedule.StartDate;
scheduledTransaction.AuthorizedPersonAliasId = person.PrimaryAliasId.Value;
scheduledTransaction.FinancialGatewayId = financialGateway.Id;
if ( scheduledTransaction.FinancialPaymentDetail == null )
{
scheduledTransaction.FinancialPaymentDetail = new FinancialPaymentDetail();
}
scheduledTransaction.FinancialPaymentDetail.SetFromPaymentInfo( paymentInfo, gateway, rockContext );
Guid sourceGuid = Guid.Empty;
if ( Guid.TryParse( GetAttributeValue( "Source" ), out sourceGuid ) )
{
var source = DefinedValueCache.Read( sourceGuid );
if ( source != null )
{
scheduledTransaction.SourceTypeValueId = source.Id;
}
}
var changeSummary = new StringBuilder();
changeSummary.AppendFormat( "{0} starting {1}", schedule.TransactionFrequencyValue.Value, schedule.StartDate.ToShortDateString() );
changeSummary.AppendLine();
changeSummary.Append( paymentInfo.CurrencyTypeValue.Value );
if ( paymentInfo.CreditCardTypeValue != null )
{
changeSummary.AppendFormat( " - {0}", paymentInfo.CreditCardTypeValue.Value );
}
changeSummary.AppendFormat( " {0}", paymentInfo.MaskedNumber );
changeSummary.AppendLine();
foreach ( var account in SelectedAccounts.Where( a => a.Amount > 0 ) )
{
var transactionDetail = new FinancialScheduledTransactionDetail();
transactionDetail.Amount = account.Amount;
transactionDetail.AccountId = account.Id;
scheduledTransaction.ScheduledTransactionDetails.Add( transactionDetail );
changeSummary.AppendFormat( "{0}: {1}", account.Name, account.Amount.FormatAsCurrency() );
changeSummary.AppendLine();
}
if ( !string.IsNullOrWhiteSpace( paymentInfo.Comment1 ) )
{
changeSummary.Append( paymentInfo.Comment1 );
changeSummary.AppendLine();
}
var transactionService = new FinancialScheduledTransactionService( rockContext );
transactionService.Add( scheduledTransaction );
rockContext.SaveChanges();
// If this is a transfer, now we can delete the old transaction
if ( _scheduledTransactionToBeTransferred != null )
{
DeleteOldTransaction( _scheduledTransactionToBeTransferred.Id );
}
// Add a note about the change
var noteType = NoteTypeCache.Read( Rock.SystemGuid.NoteType.SCHEDULED_TRANSACTION_NOTE.AsGuid() );
if ( noteType != null )
{
var noteService = new NoteService( rockContext );
var note = new Note();
note.NoteTypeId = noteType.Id;
note.EntityId = scheduledTransaction.Id;
note.Caption = "Created Transaction";
note.Text = changeSummary.ToString();
noteService.Add( note );
}
rockContext.SaveChanges();
ScheduleId = scheduledTransaction.GatewayScheduleId;
TransactionCode = scheduledTransaction.TransactionCode;
}
/// <summary>
/// Handles the CheckChanged event of the grid's IsApproved field.
/// </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 gPrayerComments_CheckChanged( object sender, RowEventArgs e )
{
bool failure = true;
if ( e.RowKeyValues != null )
{
var rockContext = new RockContext();
NoteService noteService = new NoteService( rockContext );
Note prayerComment = noteService.Get( (int)e.RowKeyValues["id"] );
if ( prayerComment != null )
{
failure = false;
rockContext.SaveChanges();
}
BindCommentsGrid();
}
if ( failure )
{
maGridWarning.Show( "Unable to approve that prayer comment", ModalAlertType.Warning );
}
}
/// <summary>
/// Handles the Click event of the lbSave 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 lbSave_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
var userLoginService = new UserLoginService( rockContext );
var userLogin = userLoginService.Queryable().Where( a => a.ApiKey == tbKey.Text ).FirstOrDefault();
if ( userLogin != null && userLogin.PersonId != int.Parse( hfRestUserId.Value ) )
{
// this key already exists in the database. Show the error and get out of here.
nbWarningMessage.Text = "This API Key already exists. Please enter a different one, or generate one by clicking the 'Generate Key' button below. ";
nbWarningMessage.Visible = true;
return;
}
rockContext.WrapTransaction( () =>
{
var personService = new PersonService( rockContext );
var changes = new List<string>();
var restUser = new Person();
if ( int.Parse( hfRestUserId.Value ) != 0 )
{
restUser = personService.Get( int.Parse( hfRestUserId.Value ) );
}
else
{
personService.Add( restUser );
rockContext.SaveChanges();
restUser.Aliases.Add( new PersonAlias { AliasPersonId = restUser.Id, AliasPersonGuid = restUser.Guid } );
}
// the rest user name gets saved as the last name on a person
History.EvaluateChange( changes, "Last Name", restUser.LastName, tbName.Text );
restUser.LastName = tbName.Text;
restUser.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_RESTUSER.AsGuid() ).Id;
if ( cbActive.Checked )
{
restUser.RecordStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid() ).Id;
}
else
{
restUser.RecordStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE.AsGuid() ).Id;
}
if ( restUser.IsValid )
{
if ( rockContext.SaveChanges() > 0 )
{
if ( changes.Any() )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
restUser.Id,
changes );
}
}
}
// the description gets saved as a system note for the person
var noteType = new NoteTypeService( rockContext )
.Get( Rock.SystemGuid.NoteType.PERSON_TIMELINE.AsGuid() );
var noteService = new NoteService( rockContext );
var note = noteService.Get( noteType.Id, restUser.Id ).FirstOrDefault();
if ( note == null )
{
note = new Note();
noteService.Add( note );
}
note.NoteTypeId = noteType.Id;
note.EntityId = restUser.Id;
note.Text = tbDescription.Text;
rockContext.SaveChanges();
// the key gets saved in the api key field of a user login (which you have to create if needed)
var entityType = new EntityTypeService( rockContext )
.Get( "Rock.Security.Authentication.Database" );
userLogin = userLoginService.GetByPersonId( restUser.Id ).FirstOrDefault();
if ( userLogin == null )
{
userLogin = new UserLogin();
userLoginService.Add( userLogin );
}
if ( string.IsNullOrWhiteSpace( userLogin.UserName ) )
{
userLogin.UserName = Guid.NewGuid().ToString();
}
userLogin.IsConfirmed = true;
userLogin.ApiKey = tbKey.Text;
userLogin.PersonId = restUser.Id;
userLogin.EntityTypeId = entityType.Id;
rockContext.SaveChanges();
} );
NavigateToParentPage();
}
/// <summary>
/// Binds the comments grid.
/// </summary>
private void BindCommentsGrid()
{
var rockContext = new RockContext();
var noteTypeService = new NoteTypeService(rockContext);
var noteType = noteTypeService.Get(Rock.SystemGuid.NoteType.PRAYER_COMMENT.AsGuid());
var noteService = new NoteService(rockContext);
var prayerComments = noteService.GetByNoteTypeId(noteType.Id);
SortProperty sortProperty = gPrayerComments.SortProperty;
// Filter by Category. First see if there is a Block Setting, otherwise use the Grid Filter
CategoryCache categoryFilter = null;
var blockCategoryGuid = GetAttributeValue("PrayerRequestCategory").AsGuidOrNull();
if (blockCategoryGuid.HasValue)
{
categoryFilter = CategoryCache.Get(blockCategoryGuid.Value);
}
if (categoryFilter == null && catpPrayerCategoryFilter.Visible)
{
int?filterCategoryId = catpPrayerCategoryFilter.SelectedValue.AsIntegerOrNull();
if (filterCategoryId.HasValue)
{
categoryFilter = CategoryCache.Get(filterCategoryId.Value);
}
}
if (categoryFilter != null)
{
// if filtered by category, only show comments for prayer requests in that category or any of its decendent categories
var categoryService = new CategoryService(rockContext);
var categories = new CategoryService(rockContext).GetAllDescendents(categoryFilter.Guid).Select(a => a.Id).ToList();
var prayerRequestQry = new PrayerRequestService(rockContext).Queryable().Where(a => a.CategoryId.HasValue &&
(a.Category.Guid == categoryFilter.Guid || categories.Contains(a.CategoryId.Value)))
.Select(a => a.Id);
prayerComments = prayerComments.Where(a => a.EntityId.HasValue && prayerRequestQry.Contains(a.EntityId.Value));
}
// Filter by Date Range
if (drpDateRange.LowerValue.HasValue)
{
DateTime startDate = drpDateRange.LowerValue.Value.Date;
prayerComments = prayerComments.Where(a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value >= startDate);
}
if (drpDateRange.UpperValue.HasValue)
{
// Add one day in order to include everything up to the end of the selected datetime.
var endDate = drpDateRange.UpperValue.Value.AddDays(1);
prayerComments = prayerComments.Where(a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value < endDate);
}
// Sort by the given property otherwise sort by the EnteredDate
if (sortProperty != null)
{
gPrayerComments.DataSource = prayerComments.Sort(sortProperty).ToList();
}
else
{
gPrayerComments.DataSource = prayerComments.OrderByDescending(n => n.CreatedDateTime).ToList();
}
gPrayerComments.DataBind();
}
/// <summary>
/// Deletes all related notes.
/// </summary>
/// <param name="prayerRequest">The prayer request.</param>
private void DeleteAllRelatedNotes( PrayerRequest prayerRequest, RockContext rockContext )
{
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( Rock.SystemGuid.NoteType.PRAYER_COMMENT.AsGuid() );
var noteService = new NoteService( rockContext );
var prayerComments = noteService.Get( noteType.Id, prayerRequest.Id );
foreach ( Note prayerComment in prayerComments )
{
noteService.Delete( prayerComment );
}
rockContext.SaveChanges();
}
/// <summary>
/// Handles the Click event of the btnConfirm 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 btnConfirm_Click( object sender, EventArgs e )
{
if ( Page.IsValid )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
var ids = Individuals.Select( i => i.PersonId ).ToList();
#region Individual Details Updates
int? newTitleId = ddlTitle.SelectedValueAsInt();
int? newSuffixId = ddlSuffix.SelectedValueAsInt();
int? newConnectionStatusId = ddlStatus.SelectedValueAsInt();
int? newRecordStatusId = ddlRecordStatus.SelectedValueAsInt();
int? newInactiveReasonId = ddlInactiveReason.SelectedValueAsInt();
string newInactiveReasonNote = tbInactiveReasonNote.Text;
Gender newGender = ddlGender.SelectedValue.ConvertToEnum<Gender>();
int? newMaritalStatusId = ddlMaritalStatus.SelectedValueAsInt();
int? newGraduationYear = null;
if ( ypGraduation.SelectedYear.HasValue )
{
newGraduationYear = ypGraduation.SelectedYear.Value;
}
int? newCampusId = cpCampus.SelectedCampusId;
bool? newEmailActive = null;
if ( !string.IsNullOrWhiteSpace( ddlIsEmailActive.SelectedValue ) )
{
newEmailActive = ddlIsEmailActive.SelectedValue == "Active";
}
EmailPreference? newEmailPreference = ddlEmailPreference.SelectedValue.ConvertToEnumOrNull<EmailPreference>();
string newEmailNote = tbEmailNote.Text;
int? newReviewReason = ddlReviewReason.SelectedValueAsInt();
string newSystemNote = tbSystemNote.Text;
string newReviewReasonNote = tbReviewReasonNote.Text;
int inactiveStatusId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ).Id;
var allChanges = new Dictionary<int, List<string>>();
var people = personService.Queryable().Where( p => ids.Contains( p.Id ) ).ToList();
foreach ( var person in people )
{
var changes = new List<string>();
allChanges.Add( person.Id, changes );
if ( SelectedFields.Contains( ddlTitle.ClientID ) )
{
History.EvaluateChange( changes, "Title", DefinedValueCache.GetName( person.TitleValueId ), DefinedValueCache.GetName( newTitleId ) );
person.TitleValueId = newTitleId;
}
if ( SelectedFields.Contains( ddlSuffix.ClientID ) )
{
History.EvaluateChange( changes, "Suffix", DefinedValueCache.GetName( person.SuffixValueId ), DefinedValueCache.GetName( newSuffixId ) );
person.SuffixValueId = newSuffixId;
}
if ( SelectedFields.Contains( ddlStatus.ClientID ) )
{
History.EvaluateChange( changes, "Connection Status", DefinedValueCache.GetName( person.ConnectionStatusValueId ), DefinedValueCache.GetName( newConnectionStatusId ) );
person.ConnectionStatusValueId = newConnectionStatusId;
}
if ( SelectedFields.Contains( ddlRecordStatus.ClientID ) )
{
History.EvaluateChange( changes, "Record Status", DefinedValueCache.GetName( person.RecordStatusValueId ), DefinedValueCache.GetName( newRecordStatusId ) );
person.RecordStatusValueId = newRecordStatusId;
if ( newRecordStatusId.HasValue && newRecordStatusId.Value == inactiveStatusId )
{
History.EvaluateChange( changes, "Inactive Reason", DefinedValueCache.GetName( person.RecordStatusReasonValueId ), DefinedValueCache.GetName( newInactiveReasonId ) );
person.RecordStatusReasonValueId = newInactiveReasonId;
if ( !string.IsNullOrWhiteSpace( newInactiveReasonNote ) )
{
History.EvaluateChange( changes, "Inactive Reason Note", person.InactiveReasonNote, newInactiveReasonNote );
person.InactiveReasonNote = newInactiveReasonNote;
}
}
}
if ( SelectedFields.Contains( ddlGender.ClientID ) )
{
History.EvaluateChange( changes, "Gender", person.Gender, newGender );
person.Gender = newGender;
}
if ( SelectedFields.Contains( ddlMaritalStatus.ClientID ) )
{
History.EvaluateChange( changes, "Marital Status", DefinedValueCache.GetName( person.MaritalStatusValueId ), DefinedValueCache.GetName( newMaritalStatusId ) );
person.MaritalStatusValueId = newMaritalStatusId;
}
if ( SelectedFields.Contains( ddlGradePicker.ClientID ) )
{
History.EvaluateChange( changes, "Graduation Year", person.GraduationYear, newGraduationYear );
person.GraduationYear = newGraduationYear;
}
if ( SelectedFields.Contains( ddlIsEmailActive.ClientID ) )
{
History.EvaluateChange( changes, "Email Is Active", person.IsEmailActive ?? true, newEmailActive.Value );
person.IsEmailActive = newEmailActive;
}
if ( SelectedFields.Contains( ddlEmailPreference.ClientID ) )
{
History.EvaluateChange( changes, "Email Preference", person.EmailPreference, newEmailPreference );
person.EmailPreference = newEmailPreference.Value;
}
if ( SelectedFields.Contains( tbEmailNote.ClientID ) )
{
History.EvaluateChange( changes, "Email Note", person.EmailNote, newEmailNote );
person.EmailNote = newEmailNote;
}
if ( SelectedFields.Contains( tbSystemNote.ClientID ) )
{
History.EvaluateChange( changes, "System Note", person.SystemNote, newSystemNote );
person.SystemNote = newSystemNote;
}
if ( SelectedFields.Contains( ddlReviewReason.ClientID ) )
{
History.EvaluateChange( changes, "Review Reason", DefinedValueCache.GetName( person.ReviewReasonValueId ), DefinedValueCache.GetName( newReviewReason ) );
person.ReviewReasonValueId = newReviewReason;
}
if ( SelectedFields.Contains( tbReviewReasonNote.ClientID ) )
{
History.EvaluateChange( changes, "Review Reason Note", person.ReviewReasonNote, newReviewReasonNote );
person.ReviewReasonNote = newReviewReasonNote;
}
}
if ( SelectedFields.Contains( cpCampus.ClientID ) && cpCampus.SelectedCampusId.HasValue )
{
int campusId = cpCampus.SelectedCampusId.Value;
Guid familyGuid = new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY );
var familyMembers = new GroupMemberService( rockContext ).Queryable()
.Where( m => ids.Contains( m.PersonId ) && m.Group.GroupType.Guid == familyGuid )
.Select( m => new { m.PersonId, m.GroupId } )
.Distinct()
.ToList();
var families = new GroupMemberService( rockContext ).Queryable()
.Where( m => ids.Contains( m.PersonId ) && m.Group.GroupType.Guid == familyGuid )
.Select( m => m.Group )
.Distinct()
.ToList();
foreach ( int personId in ids )
{
var familyIds = familyMembers.Where( m => m.PersonId == personId ).Select( m => m.GroupId ).ToList();
if ( familyIds.Count == 1 )
{
int familyId = familyIds.FirstOrDefault();
var family = families.Where( g => g.Id == familyId ).FirstOrDefault();
{
if ( family != null )
{
family.CampusId = campusId;
}
familyMembers.RemoveAll( m => m.GroupId == familyId );
}
}
}
rockContext.SaveChanges();
}
// Update following
if ( SelectedFields.Contains( ddlFollow.ClientID ) )
{
var personAliasEntityType = EntityTypeCache.Read( "Rock.Model.PersonAlias" );
if ( personAliasEntityType != null )
{
int personAliasEntityTypeId = personAliasEntityType.Id;
bool follow = true;
if ( !string.IsNullOrWhiteSpace( ddlFollow.SelectedValue ) )
{
follow = ddlFollow.SelectedValue == "Add";
}
var personAliasService = new PersonAliasService( rockContext );
var followingService = new FollowingService( rockContext );
if ( follow )
{
var paQry = personAliasService.Queryable();
var alreadyFollowingIds = followingService.Queryable()
.Where( f =>
f.EntityTypeId == personAliasEntityTypeId &&
f.PersonAlias.Id == CurrentPersonAlias.Id )
.Join( paQry, f => f.EntityId, p => p.Id, ( f, p ) => new { PersonAlias = p } )
.Select( p => p.PersonAlias.PersonId )
.Distinct()
.ToList();
foreach ( int id in ids.Where( id => !alreadyFollowingIds.Contains( id ) ) )
{
var following = new Following
{
EntityTypeId = personAliasEntityTypeId,
EntityId = ( people.FirstOrDefault( p => p.Id == id ).PrimaryAliasId ) ?? 0,
PersonAliasId = CurrentPersonAlias.Id
};
followingService.Add( following );
}
}
else
{
var paQry = personAliasService.Queryable()
.Where( p => ids.Contains( p.PersonId ) )
.Select( p => p.Id );
foreach ( var following in followingService.Queryable()
.Where( f =>
f.EntityTypeId == personAliasEntityTypeId &&
paQry.Contains( f.EntityId ) &&
f.PersonAlias.Id == CurrentPersonAlias.Id ) )
{
followingService.Delete( following );
}
}
}
}
rockContext.SaveChanges();
#endregion
#region Attributes
var selectedCategories = new List<CategoryCache>();
foreach ( string categoryGuid in GetAttributeValue( "AttributeCategories" ).SplitDelimitedValues() )
{
var category = CategoryCache.Read( categoryGuid.AsGuid(), rockContext );
if ( category != null )
{
selectedCategories.Add( category );
}
}
var attributes = new List<AttributeCache>();
var attributeValues = new Dictionary<int, string>();
int categoryIndex = 0;
foreach ( var category in selectedCategories.OrderBy( c => c.Name ) )
{
PanelWidget pw = null;
string controlId = "pwAttributes_" + category.Id.ToString();
if ( categoryIndex % 2 == 0 )
{
pw = phAttributesCol1.FindControl( controlId ) as PanelWidget;
}
else
{
pw = phAttributesCol2.FindControl( controlId ) as PanelWidget;
}
categoryIndex++;
if ( pw != null )
{
var orderedAttributeList = new AttributeService( rockContext ).GetByCategoryId( category.Id )
.OrderBy( a => a.Order ).ThenBy( a => a.Name );
foreach ( var attribute in orderedAttributeList )
{
if ( attribute.IsAuthorized( Authorization.EDIT, CurrentPerson ) )
{
var attributeCache = AttributeCache.Read( attribute.Id );
Control attributeControl = pw.FindControl( string.Format( "attribute_field_{0}", attribute.Id ) );
if ( attributeControl != null && SelectedFields.Contains( attributeControl.ClientID ) )
{
string newValue = attributeCache.FieldType.Field.GetEditValue( attributeControl, attributeCache.QualifierValues );
attributes.Add( attributeCache );
attributeValues.Add( attributeCache.Id, newValue );
}
}
}
}
}
if ( attributes.Any() )
{
foreach ( var person in people )
{
person.LoadAttributes();
foreach ( var attribute in attributes )
{
string originalValue = person.GetAttributeValue( attribute.Key );
string newValue = attributeValues[attribute.Id];
if ( ( originalValue ?? string.Empty ).Trim() != ( newValue ?? string.Empty ).Trim() )
{
Rock.Attribute.Helper.SaveAttributeValue( person, attribute, newValue, rockContext );
string formattedOriginalValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( originalValue ) )
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue( null, originalValue, attribute.QualifierValues, false );
}
string formattedNewValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
formattedNewValue = attribute.FieldType.Field.FormatValue( null, newValue, attribute.QualifierValues, false );
}
History.EvaluateChange( allChanges[person.Id], attribute.Name, formattedOriginalValue, formattedNewValue );
}
}
}
}
// Create the history records
foreach ( var changes in allChanges )
{
if ( changes.Value.Any() )
{
HistoryService.AddChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
changes.Key, changes.Value );
}
}
rockContext.SaveChanges();
#endregion
#region Add Note
if ( !string.IsNullOrWhiteSpace( tbNote.Text ) && CurrentPerson != null )
{
string text = tbNote.Text;
bool isAlert = cbIsAlert.Checked;
bool isPrivate = cbIsPrivate.Checked;
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( Rock.SystemGuid.NoteType.PERSON_TIMELINE.AsGuid() );
if ( noteType != null )
{
var notes = new List<Note>();
var noteService = new NoteService( rockContext );
foreach ( int id in ids )
{
var note = new Note();
note.IsSystem = false;
note.EntityId = id;
note.Caption = isPrivate ? "You - Personal Note" : string.Empty;
note.Text = tbNote.Text;
note.IsAlert = cbIsAlert.Checked;
note.NoteType = noteType;
notes.Add( note );
noteService.Add( note );
}
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
foreach ( var note in notes )
{
note.AllowPerson( Authorization.EDIT, CurrentPerson, rockContext );
if ( isPrivate )
{
note.MakePrivate( Authorization.VIEW, CurrentPerson, rockContext );
}
}
} );
}
}
#endregion
#region Group
int? groupId = gpGroup.SelectedValue.AsIntegerOrNull();
if ( groupId.HasValue )
{
var group = new GroupService( rockContext ).Get( groupId.Value );
if ( group != null )
{
var groupMemberService = new GroupMemberService( rockContext );
var existingMembers = groupMemberService.Queryable( "Group" )
.Where( m =>
m.GroupId == group.Id &&
ids.Contains( m.PersonId ) )
.ToList();
string action = ddlGroupAction.SelectedValue;
if ( action == "Remove" )
{
groupMemberService.DeleteRange( existingMembers );
rockContext.SaveChanges();
}
else
{
var roleId = ddlGroupRole.SelectedValueAsInt();
var status = ddlGroupMemberStatus.SelectedValueAsEnum<GroupMemberStatus>();
// Get the attribute values updated
var gm = new GroupMember();
gm.Group = group;
gm.GroupId = group.Id;
gm.LoadAttributes( rockContext );
var selectedGroupAttributes = new List<AttributeCache>();
var selectedGroupAttributeValues = new Dictionary<string, string>();
foreach ( var attributeCache in gm.Attributes.Select( a => a.Value ) )
{
Control attributeControl = phAttributes.FindControl( string.Format( "attribute_field_{0}", attributeCache.Id ) );
if ( attributeControl != null && ( action == "Add" || SelectedFields.Contains( attributeControl.ClientID ) ) )
{
string newValue = attributeCache.FieldType.Field.GetEditValue( attributeControl, attributeCache.QualifierValues );
selectedGroupAttributes.Add( attributeCache );
selectedGroupAttributeValues.Add( attributeCache.Key, newValue );
}
}
if ( action == "Add" )
{
if ( roleId.HasValue )
{
var newGroupMembers = new List<GroupMember>();
var existingIds = existingMembers.Select( m => m.PersonId ).Distinct().ToList();
foreach ( int id in ids.Where( id => !existingIds.Contains( id ) ) )
{
var groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.GroupRoleId = roleId.Value;
groupMember.GroupMemberStatus = status;
groupMember.PersonId = id;
groupMemberService.Add( groupMember );
newGroupMembers.Add( groupMember );
}
rockContext.SaveChanges();
if ( selectedGroupAttributes.Any() )
{
foreach ( var groupMember in newGroupMembers )
{
foreach ( var attribute in selectedGroupAttributes )
{
Rock.Attribute.Helper.SaveAttributeValue( groupMember, attribute, selectedGroupAttributeValues[attribute.Key], rockContext );
}
}
}
}
}
else // Update
{
if ( SelectedFields.Contains( ddlGroupRole.ClientID ) && roleId.HasValue )
{
foreach ( var member in existingMembers.Where( m => m.GroupRoleId != roleId.Value ) )
{
if ( !existingMembers.Where( m => m.PersonId == member.PersonId && m.GroupRoleId == roleId.Value ).Any() )
{
member.GroupRoleId = roleId.Value;
}
}
}
if ( SelectedFields.Contains( ddlGroupMemberStatus.ClientID ) )
{
foreach ( var member in existingMembers )
{
member.GroupMemberStatus = status;
}
}
rockContext.SaveChanges();
if ( selectedGroupAttributes.Any() )
{
foreach ( var groupMember in existingMembers )
{
foreach ( var attribute in selectedGroupAttributes )
{
Rock.Attribute.Helper.SaveAttributeValue( groupMember, attribute, selectedGroupAttributeValues[attribute.Key], rockContext );
}
}
}
}
}
}
}
#endregion
pnlEntry.Visible = false;
pnlConfirm.Visible = false;
nbResult.Text = string.Format( "{0} {1} succesfully updated.",
ids.Count().ToString( "N0" ), ( ids.Count() > 1 ? "people were" : "person was" ) ); ;
pnlResult.Visible = true;
}
}
/// <summary>
/// Add a note on the given person's record.
/// </summary>
/// <param name="personId"></param>
/// <param name="noteTypeName"></param>
/// <param name="noteText"></param>
/// <param name="noteDate">(optional) The date the note was created</param>
/// <param name="byPersonGuid">(optional) The guid of the person who created the note</param>
/// <param name="rockContext"></param>
private void AddNote( int personId, string noteTypeName, string noteText, string noteDate, string byPersonGuid, string isPrivate, string isAlert, RockContext rockContext )
{
var service = new NoteTypeService( rockContext );
var noteType = service.Get( _personEntityTypeId, noteTypeName );
if ( noteType != null )
{
// Find the person's alias
int? createdByPersonAliasId = null;
if ( byPersonGuid != null )
{
createdByPersonAliasId = _personCache[byPersonGuid.AsGuid()].PrimaryAliasId;
}
var noteService = new NoteService( rockContext );
var note = new Note()
{
IsSystem = false,
NoteTypeId = noteType.Id,
EntityId = personId,
Caption = string.Empty,
CreatedByPersonAliasId = createdByPersonAliasId,
Text = noteText,
IsAlert = isAlert.AsBoolean(),
IsPrivateNote = isPrivate.AsBoolean(),
CreatedDateTime = string.IsNullOrWhiteSpace( noteDate ) ? RockDateTime.Now : DateTime.Parse( noteDate, new CultureInfo( "en-US" ) )
};
noteService.Add( note );
}
}
public NotesController()
{
_noteService = new NoteService();
}
public NoteController(NoteService noteService) => _noteService = noteService;
/// <summary>
/// Handles the Click event of the btnMoveGroupMember 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 btnMoveGroupMember_Click(object sender, EventArgs e)
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
var groupMember = groupMemberService.Get(hfGroupMemberId.Value.AsInteger());
groupMember.LoadAttributes();
int destGroupId = gpMoveGroupMember.SelectedValue.AsInteger();
var destGroup = new GroupService(rockContext).Get(destGroupId);
var destGroupMember = groupMemberService.Queryable().Where(a =>
a.GroupId == destGroupId &&
a.PersonId == groupMember.PersonId &&
a.GroupRoleId == grpMoveGroupMember.GroupRoleId).FirstOrDefault();
if (destGroupMember != null)
{
nbMoveGroupMemberWarning.Visible = true;
nbMoveGroupMemberWarning.Text = string.Format("{0} is already in {1}", groupMember.Person, destGroupMember.Group);
return;
}
if (!grpMoveGroupMember.GroupRoleId.HasValue)
{
nbMoveGroupMemberWarning.Visible = true;
nbMoveGroupMemberWarning.Text = string.Format("Please select a Group Role");
return;
}
string canDeleteWarning;
if (!groupMemberService.CanDelete(groupMember, out canDeleteWarning))
{
nbMoveGroupMemberWarning.Visible = true;
nbMoveGroupMemberWarning.Text = string.Format("Unable to remove {0} from {1}: {2}", groupMember.Person, groupMember.Group, canDeleteWarning);
return;
}
destGroupMember = new GroupMember();
destGroupMember.GroupId = destGroupId;
destGroupMember.GroupRoleId = grpMoveGroupMember.GroupRoleId.Value;
destGroupMember.PersonId = groupMember.PersonId;
destGroupMember.LoadAttributes();
foreach (var attribute in groupMember.Attributes)
{
if (destGroupMember.Attributes.Any(a => a.Key == attribute.Key && a.Value.FieldTypeId == attribute.Value.FieldTypeId))
{
destGroupMember.SetAttributeValue(attribute.Key, groupMember.GetAttributeValue(attribute.Key));
}
}
// Un-link any registrant records that point to this group member.
foreach (var registrant in new RegistrationRegistrantService(rockContext).Queryable()
.Where(r => r.GroupMemberId == groupMember.Id))
{
registrant.GroupMemberId = null;
}
rockContext.WrapTransaction(() =>
{
groupMemberService.Add(destGroupMember);
rockContext.SaveChanges();
destGroupMember.SaveAttributeValues(rockContext);
// move any Note records that were associated with the old groupMember to the new groupMember record
if (cbMoveGroupMemberMoveNotes.Checked)
{
destGroupMember.Note = groupMember.Note;
int groupMemberEntityTypeId = EntityTypeCache.GetId <Rock.Model.GroupMember>().Value;
var noteService = new NoteService(rockContext);
var groupMemberNotes = noteService.Queryable().Where(a => a.NoteType.EntityTypeId == groupMemberEntityTypeId && a.EntityId == groupMember.Id);
foreach (var note in groupMemberNotes)
{
note.EntityId = destGroupMember.Id;
}
rockContext.SaveChanges();
}
groupMemberService.Delete(groupMember);
rockContext.SaveChanges();
destGroupMember.CalculateRequirements(rockContext, true);
});
var queryString = new Dictionary <string, string>();
queryString.Add("GroupMemberId", destGroupMember.Id.ToString());
this.NavigateToPage(this.RockPage.Guid, queryString);
}
public ActionResult Delete(int id)
{
NoteService.NoteDelete(id);
return(new JsonResult());
}
private void SaveNote()
{
NoteService.SaveAppSettings();
}
public void ShouldGetNotes()
{
string encryptionKey = "abc";
DBResult <UserProfile> profileDBResult = new DBResult <UserProfile>
{
Payload = new UserProfile()
{
EncryptionKey = encryptionKey
}
};
Mock <IUserProfileDelegate> profileDelegateMock = new Mock <IUserProfileDelegate>();
profileDelegateMock.Setup(s => s.GetUserProfile(hdid)).Returns(profileDBResult);
Mock <ICryptoDelegate> cryptoDelegateMock = new Mock <ICryptoDelegate>();
cryptoDelegateMock.Setup(s => s.Encrypt(It.IsAny <string>(), It.IsAny <string>())).Returns((string key, string text) => text + key);
cryptoDelegateMock.Setup(s => s.Decrypt(It.IsAny <string>(), It.IsAny <string>())).Returns((string key, string text) => text.Remove(text.Length - key.Length));
List <Note> noteList = new List <Note>();
noteList.Add(new Note
{
HdId = hdid,
Title = "First Note",
Text = "First Note text",
CreatedDateTime = new DateTime(2020, 1, 1)
});
noteList.Add(new Note
{
HdId = hdid,
Title = "Second Note",
Text = "Second Note text",
CreatedDateTime = new DateTime(2020, 2, 2)
});
List <UserNote> userNoteList = UserNote.CreateListFromDbModel(noteList, cryptoDelegateMock.Object, encryptionKey).ToList();
DBResult <IEnumerable <Note> > notesDBResult = new DBResult <IEnumerable <Note> >
{
Payload = noteList,
Status = Database.Constants.DBStatusCode.Read
};
Mock <INoteDelegate> noteDelegateMock = new Mock <INoteDelegate>();
noteDelegateMock.Setup(s => s.GetNotes(hdid, 0, 500)).Returns(notesDBResult);
INoteService service = new NoteService(
new Mock <ILogger <NoteService> >().Object,
noteDelegateMock.Object,
profileDelegateMock.Object,
cryptoDelegateMock.Object
);
RequestResult <IEnumerable <UserNote> > actualResult = service.GetNotes(hdid, 0, 500);
Assert.Equal(Common.Constants.ResultType.Success, actualResult.ResultStatus);
Assert.True(actualResult.ResourcePayload.IsDeepEqual(userNoteList));
}
/// <summary>
/// Binds the comments grid.
/// </summary>
private void BindCommentsGrid()
{
var rockContext = new RockContext();
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( (int)_prayerRequestEntityTypeId, "Prayer Comment" );
// TODO log exception if noteType is null
var noteService = new NoteService( rockContext );
var prayerComments = noteService.GetByNoteTypeId( noteType.Id );
SortProperty sortProperty = gPrayerComments.SortProperty;
// TODO: filter out comments that do not belong to the configured "category" grouping.
//if ( _blockInstanceGroupCategoryId != All.Id )
//{
// prayerComments = prayerComments.Where( c => c.CategoryId == _blockInstanceGroupCategoryId );
//}
// Filter by Date Range
if ( drpDateRange.LowerValue.HasValue )
{
DateTime startDate = drpDateRange.LowerValue.Value.Date;
prayerComments = prayerComments.Where( a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value >= startDate );
}
if ( drpDateRange.UpperValue.HasValue )
{
// Add one day in order to include everything up to the end of the selected datetime.
var endDate = drpDateRange.UpperValue.Value.AddDays( 1 );
prayerComments = prayerComments.Where( a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value < endDate );
}
// Sort by the given property otherwise sort by the EnteredDate
if ( sortProperty != null )
{
gPrayerComments.DataSource = prayerComments.Sort( sortProperty ).ToList();
}
else
{
gPrayerComments.DataSource = prayerComments.OrderBy( n => n.CreatedDateTime ).ToList();
}
gPrayerComments.DataBind();
}
/// <summary>
/// Handles the Click event of the lbDeleteNote 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 lbDeleteNote_Click( object sender, EventArgs e )
{
var rockPage = this.Page as RockPage;
if ( rockPage != null )
{
var currentPerson = rockPage.CurrentPerson;
var rockContext = new RockContext();
var service = new NoteService( rockContext );
Note note = null;
if ( NoteId.HasValue )
{
note = service.Get( NoteId.Value );
if ( note != null && note.IsAuthorized( Authorization.EDIT, currentPerson ) )
{
service.Delete( note );
rockContext.SaveChanges();
}
}
if ( DeleteButtonClick != null )
{
DeleteButtonClick( this, new NoteEventArgs( NoteId ) );
}
}
}
public void ShowNote(DateTime date, params string[] tags)
{
List <Note> Notes = NoteService.GetNotesForWeek(this.UserId, date, tags.ToList()).OrderBy(Note => Note.TimeStamp).ToList();
SendNotesShort(Notes);
}
public NoteServiceTest()
{
context = new TestData().GetNewInMemoryDabaseWithTestData();
noteService = new NoteService(context);
}
/// <summary>
/// Deletes the family's addresses, phone numbers, photos, viewed records, and people.
/// TODO: delete attendance codes for attendance data that's about to be deleted when
/// we delete the person record.
/// </summary>
/// <param name="families">The families.</param>
/// <param name="rockContext">The rock context.</param>
private void DeleteExistingFamilyData( XElement families, RockContext rockContext )
{
PersonService personService = new PersonService( rockContext );
PhoneNumberService phoneNumberService = new PhoneNumberService( rockContext );
PersonViewedService personViewedService = new PersonViewedService( rockContext );
PageViewService pageViewService = new PageViewService( rockContext );
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
PersonAliasService personAliasService = new PersonAliasService( rockContext );
PersonDuplicateService personDuplicateService = new PersonDuplicateService( rockContext );
NoteService noteService = new NoteService( rockContext );
AuthService authService = new AuthService( rockContext );
CommunicationService communicationService = new CommunicationService( rockContext );
CommunicationRecipientService communicationRecipientService = new CommunicationRecipientService( rockContext );
FinancialBatchService financialBatchService = new FinancialBatchService( rockContext );
FinancialTransactionService financialTransactionService = new FinancialTransactionService( rockContext );
PersonPreviousNameService personPreviousNameService = new PersonPreviousNameService( rockContext );
ConnectionRequestService connectionRequestService = new ConnectionRequestService( rockContext );
ConnectionRequestActivityService connectionRequestActivityService = new ConnectionRequestActivityService( rockContext );
// delete the batch data
List<int> imageIds = new List<int>();
foreach ( var batch in financialBatchService.Queryable().Where( b => b.Name.StartsWith( "SampleData" ) ) )
{
imageIds.AddRange( batch.Transactions.SelectMany( t => t.Images ).Select( i => i.BinaryFileId ).ToList() );
financialTransactionService.DeleteRange( batch.Transactions );
financialBatchService.Delete( batch );
}
// delete all transaction images
foreach ( var image in binaryFileService.GetByIds( imageIds ) )
{
binaryFileService.Delete( image );
}
foreach ( var elemFamily in families.Elements( "family" ) )
{
Guid guid = elemFamily.Attribute( "guid" ).Value.Trim().AsGuid();
GroupService groupService = new GroupService( rockContext );
Group family = groupService.Get( guid );
if ( family != null )
{
var groupMemberService = new GroupMemberService( rockContext );
var members = groupMemberService.GetByGroupId( family.Id, true );
// delete the people records
string errorMessage;
List<int> photoIds = members.Select( m => m.Person ).Where( p => p.PhotoId != null ).Select( a => (int)a.PhotoId ).ToList();
foreach ( var person in members.Select( m => m.Person ) )
{
person.GivingGroup = null;
person.GivingGroupId = null;
person.PhotoId = null;
// delete phone numbers
foreach ( var phone in phoneNumberService.GetByPersonId( person.Id ) )
{
if ( phone != null )
{
phoneNumberService.Delete( phone );
}
}
// delete communication recipient
foreach ( var recipient in communicationRecipientService.Queryable().Where( r => r.PersonAlias.PersonId == person.Id ) )
{
communicationRecipientService.Delete( recipient );
}
// delete communication
foreach ( var communication in communicationService.Queryable().Where( c => c.SenderPersonAliasId == person.PrimaryAlias.Id ) )
{
communicationService.Delete( communication );
}
// delete person viewed records
foreach ( var view in personViewedService.GetByTargetPersonId( person.Id ) )
{
personViewedService.Delete( view );
}
// delete page viewed records
foreach ( var view in pageViewService.GetByPersonId( person.Id ) )
{
pageViewService.Delete( view );
}
// delete notes created by them or on their record.
foreach ( var note in noteService.Queryable().Where ( n => n.CreatedByPersonAlias.PersonId == person.Id
|| (n.NoteType.EntityTypeId == _personEntityTypeId && n.EntityId == person.Id ) ) )
{
noteService.Delete( note );
}
// delete previous names on their records
foreach ( var previousName in personPreviousNameService.Queryable().Where( r => r.PersonAlias.PersonId == person.Id ) )
{
personPreviousNameService.Delete( previousName );
}
// delete any GroupMember records they have
foreach ( var groupMember in groupMemberService.Queryable().Where( gm => gm.PersonId == person.Id ) )
{
groupMemberService.Delete( groupMember );
}
//// delete any Authorization data
//foreach ( var auth in authService.Queryable().Where( a => a.PersonId == person.Id ) )
//{
// authService.Delete( auth );
//}
// delete their aliases
foreach ( var alias in personAliasService.Queryable().Where( a => a.PersonId == person.Id ) )
{
foreach ( var duplicate in personDuplicateService.Queryable().Where( d => d.DuplicatePersonAliasId == alias.Id ) )
{
personDuplicateService.Delete( duplicate );
}
personAliasService.Delete( alias );
}
// delete any connection requests tied to them
foreach ( var request in connectionRequestService.Queryable().Where( r => r.PersonAlias.PersonId == person.Id || r.ConnectorPersonAlias.PersonId == person.Id ) )
{
connectionRequestActivityService.DeleteRange( request.ConnectionRequestActivities );
connectionRequestService.Delete( request );
}
// Save these changes so the CanDelete passes the check...
//rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
if ( personService.CanDelete( person, out errorMessage ) )
{
personService.Delete( person );
//rockContext.ChangeTracker.DetectChanges();
//rockContext.SaveChanges( disablePrePostProcessing: true );
}
else
{
throw new Exception( string.Format( "Trying to delete {0}, but: {1}", person.FullName, errorMessage ) );
}
}
//rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
// delete all member photos
foreach ( var photo in binaryFileService.GetByIds( photoIds ) )
{
binaryFileService.Delete( photo );
}
DeleteGroupAndMemberData( family, rockContext );
}
}
}
public void ShowCurrentNote()
{
List <Note> Notes = NoteService.GetCurrentNote(this.UserId).OrderBy(Note => Note.TimeStamp).ToList();
SendNotesShort(Notes);
}
/// <summary>
/// Handles the Click event of the lbSaveNote 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 lbSaveNote_Click( object sender, EventArgs e )
{
var rockPage = this.Page as RockPage;
if (rockPage != null && NoteTypeId.HasValue)
{
var currentPerson = rockPage.CurrentPerson;
var rockContext = new RockContext();
var service = new NoteService( rockContext );
Note note = null;
if ( NoteId.HasValue )
{
note = service.Get( NoteId.Value );
}
bool newNote = false;
if ( note == null )
{
newNote = true;
note = new Note();
note.IsSystem = false;
note.NoteTypeId = NoteTypeId.Value;
note.EntityId = EntityId;
note.SourceTypeValueId = SourceTypeValueId;
service.Add( note );
}
note.Caption = IsPrivate ? "You - Personal Note" : string.Empty;
note.Text = Text;
note.IsAlert = IsAlert;
rockContext.SaveChanges();
if ( newNote )
{
note.AllowPerson( Authorization.EDIT, currentPerson );
}
if ( IsPrivate && !note.IsPrivate( Authorization.VIEW, currentPerson ) )
{
note.MakePrivate( Authorization.VIEW, currentPerson );
}
if ( !IsPrivate && note.IsPrivate( Authorization.VIEW, currentPerson ) )
{
note.MakeUnPrivate( Authorization.VIEW, currentPerson );
}
if ( SaveButtonClick != null )
{
SaveButtonClick( this, new NoteEventArgs( note.Id ) );
}
}
}
/// <summary>
/// Saves the comment for the prayer request being viewed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void bbtnSaveComment_Click( object sender, EventArgs e )
{
if ( string.IsNullOrWhiteSpace( tbComment.Text ) )
{
return;
}
int prayerRequestId = hfIdValue.ValueAsInt();
NoteService service = new NoteService();
var note = new Note();
note.IsSystem = false;
note.IsAlert = false;
note.NoteTypeId = PrayerCommentNoteTypeId;
note.EntityId = prayerRequestId;
note.CreatedByPersonId = CurrentPersonId;
note.CreationDateTime = DateTime.Now;
note.Text = Sanitizer.GetSafeHtmlFragment( tbComment.Text.Trim() );
service.Add( note, CurrentPersonId );
service.Save( note, CurrentPersonId );
tbComment.Text = "";
ShowComments( prayerRequestId );
}
/// <summary>
/// Rebuilds the notes.
/// </summary>
/// <param name="setSelection">if set to <c>true</c> [set selection].</param>
public void RebuildNotes( bool setSelection )
{
ClearNotes();
ShowMoreOption = false;
int? currentPersonId = null;
var currentPerson = GetCurrentPerson();
if ( currentPerson != null )
{
currentPersonId = currentPerson.Id;
_noteNew.CreatedByPhotoId = currentPerson.PhotoId;
_noteNew.CreatedByGender = currentPerson.Gender;
_noteNew.CreatedByName = currentPerson.FullName;
_noteNew.CreatedByPersonId = currentPerson.Id;
_noteNew.CreatedByAge = currentPerson.Age;
}
else
{
_noteNew.CreatedByPhotoId = null;
_noteNew.CreatedByGender = Gender.Male;
_noteNew.CreatedByName = string.Empty;
_noteNew.CreatedByPersonId = null;
_noteNew.CreatedByAge = null;
}
_noteNew.EntityId = EntityId;
if ( ViewableNoteTypes != null && ViewableNoteTypes.Any() && EntityId.HasValue )
{
using ( var rockContext = new RockContext() )
{
var viewableNoteTypeIds = ViewableNoteTypes.Select( t => t.Id ).ToList();
var qry = new NoteService( rockContext ).Queryable( "CreatedByPersonAlias.Person" )
.Where( n =>
viewableNoteTypeIds.Contains( n.NoteTypeId ) &&
n.EntityId == EntityId.Value );
if ( SortDirection == ListSortDirection.Descending )
{
qry = qry.OrderByDescending( n => n.IsAlert == true )
.ThenByDescending( n => n.CreatedDateTime );
}
else
{
qry = qry.OrderByDescending( n => n.IsAlert == true )
.ThenBy( n => n.CreatedDateTime );
}
var notes = qry.ToList();
NoteCount = notes.Count();
int i = 0;
foreach ( var note in notes )
{
if ( SortDirection == ListSortDirection.Descending && i >= DisplayCount )
{
ShowMoreOption = true;
break;
}
if ( note.IsAuthorized( Authorization.VIEW, currentPerson ) )
{
var noteEditor = new NoteControl();
noteEditor.NoteTypes = EditableNoteTypes;
noteEditor.ID = string.Format( "note_{0}", note.Guid.ToString().Replace( "-", "_" ) );
noteEditor.Note = note;
noteEditor.IsPrivate = note.IsPrivateNote;
noteEditor.CanEdit = note.IsAuthorized( Authorization.ADMINISTRATE, currentPerson );
noteEditor.SaveButtonClick += note_Updated;
noteEditor.DeleteButtonClick += note_Updated;
Controls.Add( noteEditor );
i++;
}
}
}
}
}
/// <summary>
/// Binds all comments for the given prayer request.
/// </summary>
/// <param name="prayerRequest">a prayer request</param>
private void ShowComments( PrayerRequest prayerRequest )
{
var notes = new List<Note>();
notes = new NoteService().Get( (int)PrayerCommentNoteTypeId, prayerRequest.Id ).OrderBy( n => n.CreationDateTime ).ToList();
lMeIconHtml.Text = GetPhotoUrl( CurrentPerson, cssClassName: "media-object" );
rptComments.DataSource = notes;
rptComments.DataBind();
}
/// <summary>
/// Processes the confirmation.
/// </summary>
/// <param name="errorMessage">The error message.</param>
/// <returns></returns>
private bool ProcessConfirmation( out string errorMessage )
{
var rockContext = new RockContext();
if ( string.IsNullOrWhiteSpace( TransactionCode ) )
{
GatewayComponent gateway = hfPaymentTab.Value == "ACH" ? _achGateway : _ccGateway;
if ( gateway == null )
{
errorMessage = "There was a problem creating the payment gateway information";
return false;
}
Person person = GetPerson( true );
if ( person == null )
{
errorMessage = "There was a problem creating the person information";
return false;
}
if ( !person.PrimaryAliasId.HasValue)
{
errorMessage = "There was a problem creating the person's primary alias";
return false;
}
PaymentInfo paymentInfo = GetPaymentInfo();
if ( paymentInfo == null )
{
errorMessage = "There was a problem creating the payment information";
return false;
}
else
{
paymentInfo.FirstName = person.FirstName;
paymentInfo.LastName = person.LastName;
}
if ( paymentInfo.CreditCardTypeValue != null )
{
CreditCardTypeValueId = paymentInfo.CreditCardTypeValue.Id;
}
PaymentSchedule schedule = GetSchedule();
if ( schedule != null )
{
schedule.PersonId = person.Id;
var scheduledTransaction = gateway.AddScheduledPayment( schedule, paymentInfo, out errorMessage );
if ( scheduledTransaction != null )
{
scheduledTransaction.TransactionFrequencyValueId = schedule.TransactionFrequencyValue.Id;
scheduledTransaction.AuthorizedPersonAliasId = person.PrimaryAliasId.Value;
scheduledTransaction.GatewayEntityTypeId = EntityTypeCache.Read( gateway.TypeGuid ).Id;
scheduledTransaction.CurrencyTypeValueId = paymentInfo.CurrencyTypeValue.Id;
scheduledTransaction.CreditCardTypeValueId = CreditCardTypeValueId;
var changeSummary = new StringBuilder();
changeSummary.AppendFormat( "{0} starting {1}", schedule.TransactionFrequencyValue.Value, schedule.StartDate.ToShortDateString() );
changeSummary.AppendLine();
changeSummary.Append( paymentInfo.CurrencyTypeValue.Value );
if (paymentInfo.CreditCardTypeValue != null)
{
changeSummary.AppendFormat( " - {0}", paymentInfo.CreditCardTypeValue.Value );
}
changeSummary.AppendFormat( " {0}", paymentInfo.MaskedNumber );
changeSummary.AppendLine();
foreach ( var account in SelectedAccounts.Where( a => a.Amount > 0 ) )
{
var transactionDetail = new FinancialScheduledTransactionDetail();
transactionDetail.Amount = account.Amount;
transactionDetail.AccountId = account.Id;
scheduledTransaction.ScheduledTransactionDetails.Add( transactionDetail );
changeSummary.AppendFormat( "{0}: {1:C2}", account.Name, account.Amount );
changeSummary.AppendLine();
}
var transactionService = new FinancialScheduledTransactionService( rockContext );
transactionService.Add( scheduledTransaction );
rockContext.SaveChanges();
// Add a note about the change
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( scheduledTransaction.TypeId, "Note" );
var noteService = new NoteService( rockContext );
var note = new Note();
note.NoteTypeId = noteType.Id;
note.EntityId = scheduledTransaction.Id;
note.Caption = "Created Transaction";
note.Text = changeSummary.ToString();
noteService.Add( note );
rockContext.SaveChanges();
ScheduleId = scheduledTransaction.GatewayScheduleId;
TransactionCode = scheduledTransaction.TransactionCode;
}
else
{
return false;
}
}
else
{
var transaction = gateway.Charge( paymentInfo, out errorMessage );
if ( transaction != null )
{
transaction.TransactionDateTime = RockDateTime.Now;
transaction.AuthorizedPersonAliasId = person.PrimaryAliasId;
transaction.GatewayEntityTypeId = gateway.TypeId;
transaction.TransactionTypeValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION ) ).Id;
transaction.CurrencyTypeValueId = paymentInfo.CurrencyTypeValue.Id;
transaction.CreditCardTypeValueId = CreditCardTypeValueId;
Guid sourceGuid = Guid.Empty;
if ( Guid.TryParse( GetAttributeValue( "Source" ), out sourceGuid ) )
{
transaction.SourceTypeValueId = DefinedValueCache.Read( sourceGuid ).Id;
}
foreach ( var account in SelectedAccounts.Where( a => a.Amount > 0 ) )
{
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.Amount = account.Amount;
transactionDetail.AccountId = account.Id;
transaction.TransactionDetails.Add( transactionDetail );
}
var batchService = new FinancialBatchService( rockContext );
// Get the batch
var batch = batchService.Get(
GetAttributeValue( "BatchNamePrefix" ),
paymentInfo.CurrencyTypeValue,
paymentInfo.CreditCardTypeValue,
transaction.TransactionDateTime.Value,
gateway.BatchTimeOffset );
batch.ControlAmount += transaction.TotalAmount;
transaction.BatchId = batch.Id;
batch.Transactions.Add( transaction );
rockContext.SaveChanges();
TransactionCode = transaction.TransactionCode;
}
else
{
return false;
}
}
tdTransactionCodeReceipt.Description = TransactionCode;
tdTransactionCodeReceipt.Visible = !string.IsNullOrWhiteSpace( TransactionCode );
tdScheduleId.Description = ScheduleId;
tdScheduleId.Visible = !string.IsNullOrWhiteSpace( ScheduleId );
tdNameReceipt.Description = paymentInfo.FullName;
tdPhoneReceipt.Description = paymentInfo.Phone;
tdEmailReceipt.Description = paymentInfo.Email;
tdAddressReceipt.Description = string.Format( "{0} {1}, {2} {3}", paymentInfo.Street1, paymentInfo.City, paymentInfo.State, paymentInfo.PostalCode );
rptAccountListReceipt.DataSource = SelectedAccounts.Where( a => a.Amount != 0 );
rptAccountListReceipt.DataBind();
tdTotalReceipt.Description = paymentInfo.Amount.ToString( "C" );
tdPaymentMethodReceipt.Description = paymentInfo.CurrencyTypeValue.Description;
tdAccountNumberReceipt.Description = paymentInfo.MaskedNumber;
tdWhenReceipt.Description = schedule != null ? schedule.ToString() : "Today";
// If there was a transaction code returned and this was not already created from a previous saved account,
// show the option to save the account.
if ( !( paymentInfo is ReferencePaymentInfo ) && !string.IsNullOrWhiteSpace( TransactionCode ) )
{
cbSaveAccount.Visible = true;
pnlSaveAccount.Visible = true;
txtSaveAccount.Visible = true;
// If current person does not have a login, have them create a username and password
phCreateLogin.Visible = !new UserLoginService( rockContext ).GetByPersonId( person.Id ).Any();
}
else
{
pnlSaveAccount.Visible = false;
}
return true;
}
else
{
pnlDupWarning.Visible = true;
divActions.Visible = false;
errorMessage = string.Empty;
return false;
}
}
/// <summary>
/// Binds the comments grid.
/// </summary>
private void BindCommentsGrid()
{
var rockContext = new RockContext();
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( Rock.SystemGuid.NoteType.PRAYER_COMMENT.AsGuid() );
var noteService = new NoteService( rockContext );
var prayerComments = noteService.GetByNoteTypeId( noteType.Id );
SortProperty sortProperty = gPrayerComments.SortProperty;
// Filter by Category. First see if there is a Block Setting, otherwise use the Grid Filter
CategoryCache categoryFilter = null;
var blockCategoryGuid = GetAttributeValue( "PrayerRequestCategory" ).AsGuidOrNull();
if ( blockCategoryGuid.HasValue )
{
categoryFilter = CategoryCache.Read( blockCategoryGuid.Value );
}
if ( categoryFilter == null && catpPrayerCategoryFilter.Visible )
{
int? filterCategoryId = catpPrayerCategoryFilter.SelectedValue.AsIntegerOrNull();
if ( filterCategoryId.HasValue )
{
categoryFilter = CategoryCache.Read( filterCategoryId.Value );
}
}
if ( categoryFilter != null )
{
// if filtered by category, only show comments for prayer requests in that category or any of its decendent categories
var categoryService = new CategoryService( rockContext );
var categories = new CategoryService( rockContext ).GetAllDescendents( categoryFilter.Guid ).Select( a => a.Id ).ToList();
var prayerRequestQry = new PrayerRequestService( rockContext ).Queryable().Where( a => a.CategoryId.HasValue &&
( a.Category.Guid == categoryFilter.Guid || categories.Contains( a.CategoryId.Value ) ) )
.Select( a => a.Id );
prayerComments = prayerComments.Where( a => a.EntityId.HasValue && prayerRequestQry.Contains( a.EntityId.Value ) );
}
// Filter by Date Range
if ( drpDateRange.LowerValue.HasValue )
{
DateTime startDate = drpDateRange.LowerValue.Value.Date;
prayerComments = prayerComments.Where( a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value >= startDate );
}
if ( drpDateRange.UpperValue.HasValue )
{
// Add one day in order to include everything up to the end of the selected datetime.
var endDate = drpDateRange.UpperValue.Value.AddDays( 1 );
prayerComments = prayerComments.Where( a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value < endDate );
}
// Sort by the given property otherwise sort by the EnteredDate
if ( sortProperty != null )
{
gPrayerComments.DataSource = prayerComments.Sort( sortProperty ).ToList();
}
else
{
gPrayerComments.DataSource = prayerComments.OrderByDescending( n => n.CreatedDateTime ).ToList();
}
gPrayerComments.DataBind();
}
/// <summary>
/// Handles the Click event of the lbAddNote control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
void lbAddNote_Click( object sender, EventArgs e )
{
var service = new NoteService();
var note = new Note();
note.IsSystem = false;
note.IsAlert = false;
note.NoteTypeId = noteType.Id;
note.EntityId = contextEntity.Id;
note.CreatedByPersonId = CurrentPersonId;
note.CreationDateTime = DateTime.Now;
note.Text = tbNewNote.Text;
if ( noteType.Sources != null )
{
var source = noteType.Sources.DefinedValues.FirstOrDefault();
if ( source != null )
{
note.SourceTypeValueId = source.Id;
}
}
service.Add( note, CurrentPersonId );
service.Save( note, CurrentPersonId );
ShowNotes();
}
public void ShowCurrentNote(params string[] tags)
{
List <Note> Notes = NoteService.GetCurrentNote(this.UserId, tags.ToList()).OrderBy(Note => Note.TimeStamp).ToList();
SendNotesShort(Notes);
}
/// <summary>
/// Binds the comments grid.
/// </summary>
private void BindCommentsGrid()
{
var rockContext = new RockContext();
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( Rock.SystemGuid.NoteType.PRAYER_COMMENT.AsGuid() );
// TODO log exception if noteType is null
var noteService = new NoteService( rockContext );
var prayerComments = noteService.GetByNoteTypeId( noteType.Id );
SortProperty sortProperty = gPrayerComments.SortProperty;
if ( _blockInstancePrayerRequestCategoryGuid.HasValue )
{
// if filtered by category, only show comments for prayer requests in that category or any of its decendent categories
var categoryService = new CategoryService( rockContext );
if ( _blockInstancePrayerRequestCategoryGuid.HasValue )
{
var categories = new CategoryService( rockContext ).GetAllDescendents( _blockInstancePrayerRequestCategoryGuid.Value ).Select( a => a.Id ).ToList();
var prayerRequestQry = new PrayerRequestService( rockContext ).Queryable().Where( a => a.CategoryId.HasValue &&
( a.Category.Guid == _blockInstancePrayerRequestCategoryGuid.Value || categories.Contains( a.CategoryId.Value ) ) )
.Select( a => a.Id );
prayerComments = prayerComments.Where( a => a.EntityId.HasValue && prayerRequestQry.Contains( a.EntityId.Value ) );
}
}
// Filter by Date Range
if ( drpDateRange.LowerValue.HasValue )
{
DateTime startDate = drpDateRange.LowerValue.Value.Date;
prayerComments = prayerComments.Where( a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value >= startDate );
}
if ( drpDateRange.UpperValue.HasValue )
{
// Add one day in order to include everything up to the end of the selected datetime.
var endDate = drpDateRange.UpperValue.Value.AddDays( 1 );
prayerComments = prayerComments.Where( a => a.CreatedDateTime.HasValue && a.CreatedDateTime.Value < endDate );
}
// Sort by the given property otherwise sort by the EnteredDate
if ( sortProperty != null )
{
gPrayerComments.DataSource = prayerComments.Sort( sortProperty ).ToList();
}
else
{
gPrayerComments.DataSource = prayerComments.OrderBy( n => n.CreatedDateTime ).ToList();
}
gPrayerComments.DataBind();
}
private void ShowNotes()
{
phNotesBefore.Controls.Clear();
phNotesAfter.Controls.Clear();
var service = new NoteService();
foreach ( var note in service.Get( noteType.Id, contextEntity.Id ) )
{
if ( note.IsAuthorized( "View", CurrentPerson ) )
{
if ( prayerComment != null && note.Id == prayerComment.Id )
{
ShowEditDetails( note );
}
else
{
AddNoteHtml( note );
}
}
}
}
/// <summary>
/// Deletes all related notes.
/// </summary>
/// <param name="prayerRequest">The prayer request.</param>
private void DeleteAllRelatedNotes( PrayerRequest prayerRequest )
{
var rockContext = new RockContext();
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( _prayerRequestEntityTypeId.Value, "Prayer Comment" );
var noteService = new NoteService( rockContext );
var prayerComments = noteService.Get( noteType.Id, prayerRequest.Id );
foreach ( Note prayerComment in prayerComments )
{
noteService.Delete( prayerComment );
rockContext.SaveChanges();
}
}
private void SaveNote()
{
int noteId = 0;
if ( ! int.TryParse( hfNoteId.Value, out noteId ) )
{
return;
}
NoteService noteService = new NoteService();
Note note = noteService.Get( noteId );
if ( note != null )
{
note.Text = dtbText.Text;
note.Caption = dtbCaption.Text;
if ( !Page.IsValid )
{
return;
}
if ( !note.IsValid )
{
// field controls render error messages
return;
}
noteService.Save( note, CurrentPersonId );
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute( RockContext rockContext, WorkflowAction action, Object entity, out List<string> errorMessages )
{
errorMessages = new List<string>();
Guid? groupGuid = null;
Person person = null;
Group group = null;
string noteValue = string.Empty;
string captionValue = string.Empty;
bool isAlert = false;
// get the group attribute
Guid groupAttributeGuid = GetAttributeValue( action, "Group" ).AsGuid();
if ( !groupAttributeGuid.IsEmpty() )
{
groupGuid = action.GetWorklowAttributeValue( groupAttributeGuid ).AsGuidOrNull();
if ( groupGuid.HasValue )
{
group = new GroupService( rockContext ).Get( groupGuid.Value );
if ( group == null )
{
errorMessages.Add( "The group provided does not exist." );
}
}
else
{
errorMessages.Add( "Invalid group provided." );
}
}
// get person alias guid
Guid personAliasGuid = Guid.Empty;
string personAttribute = GetAttributeValue( action, "Person" );
Guid guid = personAttribute.AsGuid();
if ( !guid.IsEmpty() )
{
var attribute = AttributeCache.Read( guid, rockContext );
if ( attribute != null )
{
string value = action.GetWorklowAttributeValue( guid );
personAliasGuid = value.AsGuid();
}
if ( personAliasGuid != Guid.Empty )
{
person = new PersonAliasService( rockContext ).Queryable()
.Where( p => p.Guid.Equals( personAliasGuid ) )
.Select( p => p.Person )
.FirstOrDefault();
}
else
{
errorMessages.Add( "The person could not be found!" );
}
}
// get caption
captionValue = GetAttributeValue( action, "Caption" );
guid = captionValue.AsGuid();
if ( guid.IsEmpty() )
{
captionValue = captionValue.ResolveMergeFields( GetMergeFields( action ) );
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue( guid );
if ( workflowAttributeValue != null )
{
captionValue = workflowAttributeValue;
}
}
// get group member note
noteValue = GetAttributeValue( action, "Note" );
guid = noteValue.AsGuid();
if ( guid.IsEmpty() )
{
noteValue = noteValue.ResolveMergeFields( GetMergeFields( action ) );
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue( guid );
if ( workflowAttributeValue != null )
{
noteValue = workflowAttributeValue;
}
}
// get alert type
string isAlertString = GetAttributeValue( action, "IsAlert" );
guid = isAlertString.AsGuid();
if ( guid.IsEmpty() )
{
isAlert = isAlertString.AsBoolean();
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue( guid );
if ( workflowAttributeValue != null )
{
isAlert = workflowAttributeValue.AsBoolean();
}
}
// get note type
NoteTypeCache noteType = null;
Guid noteTypeGuid = GetAttributeValue( action, "NoteType" ).AsGuid();
if ( !noteTypeGuid.IsEmpty() )
{
noteType = NoteTypeCache.Read( noteTypeGuid, rockContext );
if (noteType == null )
{
errorMessages.Add( "The note type provided does not exist." );
}
}
else
{
errorMessages.Add( "Invalid note type provided." );
}
// set note
if ( group != null && person != null && noteType != null )
{
var groupMembers = new GroupMemberService( rockContext ).Queryable()
.Where( m => m.Group.Guid == groupGuid && m.PersonId == person.Id ).ToList();
if ( groupMembers.Count() > 0 )
{
foreach ( var groupMember in groupMembers )
{
NoteService noteservice = new NoteService( rockContext );
Note note = new Note();
noteservice.Add( note );
note.NoteTypeId = noteType.Id;
note.Text = noteValue;
note.IsAlert = isAlert;
note.Caption = captionValue;
note.EntityId = groupMember.Id;
rockContext.SaveChanges();
}
}
else
{
errorMessages.Add( string.Format("{0} is not a member of the group {1}.", person.FullName, group.Name ));
}
}
errorMessages.ForEach( m => action.AddLogEntry( m, true ) );
return true;
}
/// <summary>
/// Saves the person notes.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="previousRegistrantIds">The previous registrants.</param>
/// <param name="registration">The registration.</param>
private void SavePersonNotes( RockContext rockContext, List<int> previousRegistrantIds, Registration registration )
{
// Setup Note settings
NoteTypeCache noteType = null;
if ( RegistrationTemplate != null && RegistrationTemplate.AddPersonNote )
{
noteType = NoteTypeCache.Read( Rock.SystemGuid.NoteType.PERSON_EVENT_REGISTRATION.AsGuid() );
if ( noteType != null )
{
var noteService = new NoteService( rockContext );
var personAliasService = new PersonAliasService( rockContext );
Person registrar = null;
if ( registration.PersonAliasId.HasValue )
{
registrar = personAliasService.GetPerson( registration.PersonAliasId.Value );
}
var registrantNames = new List<string>();
// Get each registrant
foreach ( var registrantPersonAliasId in registration.Registrants
.Where( r => r.PersonAliasId.HasValue )
.Select( r => r.PersonAliasId.Value )
.ToList() )
{
var registrant = personAliasService.GetPerson( registrantPersonAliasId );
if ( registrant != null && !previousRegistrantIds.Contains( registrant.Id ) )
{
var noteText = new StringBuilder();
noteText.AppendFormat( "Registered for {0}", RegistrationInstanceState.Name );
if ( registrar != null && registrar.Id != registrant.Id )
{
noteText.AppendFormat( " by {0}", registrar.FullName );
registrantNames.Add( registrant.FullName );
}
if ( registrar != null && ( RegistrationState.FirstName != registrar.NickName || RegistrationState.LastName != registrar.LastName ) )
{
noteText.AppendFormat( " by {0}", RegistrationState.FirstName + " " + RegistrationState.LastName );
}
if ( noteText.Length > 0 )
{
var note = new Note();
note.NoteTypeId = noteType.Id;
note.IsSystem = false;
note.IsAlert = false;
note.IsPrivateNote = false;
note.EntityId = registrant.Id;
note.Caption = string.Empty;
note.Text = noteText.ToString();
noteService.Add( note );
}
var changes = new List<string> { "Registered for" };
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_REGISTRATION.AsGuid(),
registrant.Id,
changes,
RegistrationInstanceState.Name,
typeof( Registration ),
registration.Id,
false,
registration.PersonAliasId );
}
}
if ( registrar != null && registrantNames.Any() )
{
string namesText = string.Empty;
if ( registrantNames.Count >= 2 )
{
int lessOne = registrantNames.Count - 1;
namesText = registrantNames.Take( lessOne ).ToList().AsDelimited( ", " ) +
" and " +
registrantNames.Skip( lessOne ).Take( 1 ).First() + " ";
}
else
{
namesText = registrantNames.First() + " ";
}
var note = new Note();
note.NoteTypeId = noteType.Id;
note.IsSystem = false;
note.IsAlert = false;
note.IsPrivateNote = false;
note.EntityId = registrar.Id;
note.Caption = string.Empty;
note.Text = string.Format( "Registered {0} for {1}", namesText, RegistrationInstanceState.Name );
noteService.Add( note );
var changes = new List<string> { string.Format( "Registered {0} for", namesText ) };
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_REGISTRATION.AsGuid(),
registrar.Id,
changes,
RegistrationInstanceState.Name,
typeof( Registration ),
registration.Id,
false,
registration.PersonAliasId );
}
rockContext.SaveChanges();
}
}
}
/// <summary>
/// Handles the Delete event of the gPrayerComments 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 gPrayerComments_Delete( object sender, RowEventArgs e )
{
var rockContext = new RockContext();
NoteService noteService = new NoteService( rockContext );
Note note = noteService.Get( (int)e.RowKeyValues["id"] );
if ( note != null )
{
string errorMessage;
if ( !noteService.CanDelete( note, out errorMessage ) )
{
maGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
noteService.Delete( note );
rockContext.SaveChanges();
}
BindCommentsGrid();
}
/// <summary>
/// Add a note on the given person's record.
/// </summary>
/// <param name="personId"></param>
/// <param name="noteTypeName"></param>
/// <param name="noteText"></param>
/// <param name="noteDate">(optional) The date the note was created</param>
/// <param name="byPersonGuid">(optional) The guid of the person who created the note</param>
/// <param name="rockContext"></param>
private void AddNote( int personId, string noteTypeName, string noteText, string noteDate, string byPersonGuid, string isPrivate, RockContext rockContext )
{
var service = new NoteTypeService( rockContext );
var noteType = service.Get( _personEntityTypeId, noteTypeName );
// Find the person's alias
int? createdByPersonAliasId = null;
if ( byPersonGuid != null )
{
createdByPersonAliasId = _personCache[byPersonGuid.AsGuid()].PrimaryAliasId;
}
var noteService = new NoteService( rockContext );
var note = new Note()
{
IsSystem = false,
NoteTypeId = noteType.Id,
EntityId = personId,
Caption = string.Empty,
CreatedByPersonAliasId = createdByPersonAliasId,
Text = noteText,
CreatedDateTime = string.IsNullOrWhiteSpace( noteDate ) ? RockDateTime.Now : DateTime.Parse( noteDate, new CultureInfo( "en-US" ) )
};
noteService.Add( note );
if ( isPrivate.AsBoolean() )
{
rockContext.SaveChanges( disablePrePostProcessing: true );
note.MakePrivate( Rock.Security.Authorization.VIEW, _personCache[byPersonGuid.AsGuid()], rockContext );
}
}
/// <summary>
/// Reactivates the specified scheduled transaction.
/// </summary>
/// <param name="scheduledTransaction">The scheduled transaction.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public bool Reactivate( FinancialScheduledTransaction scheduledTransaction, out string errorMessages )
{
if ( scheduledTransaction != null &&
scheduledTransaction.FinancialGateway != null &&
scheduledTransaction.FinancialGateway.IsActive )
{
if ( scheduledTransaction.FinancialGateway.Attributes == null )
{
scheduledTransaction.FinancialGateway.LoadAttributes( (RockContext)this.Context );
}
var gateway = scheduledTransaction.FinancialGateway.GetGatewayComponent();
if ( gateway != null )
{
if ( gateway.ReactivateScheduledPayment( scheduledTransaction, out errorMessages ) )
{
var noteTypeService = new NoteTypeService( (RockContext)this.Context );
var noteType = noteTypeService.Get( Rock.SystemGuid.NoteType.SCHEDULED_TRANSACTION_NOTE.AsGuid() );
if ( noteType != null )
{
var noteService = new NoteService( (RockContext)this.Context );
var note = new Note();
note.NoteTypeId = noteType.Id;
note.EntityId = scheduledTransaction.Id;
note.Caption = "Reactivated Transaction";
noteService.Add( note );
}
return true;
}
else
{
return false;
}
}
}
errorMessages = "Gateway is invalid or not active";
return false;
}
public void ShowNotes(DateTime start, DateTime end, params string[] tags)
{
List <Note> Notes = NoteService.GetNotes(this.UserId, start, end, tags.ToList()).OrderBy(Note => Note.TimeStamp).ToList();
SendNotesLong(Notes);
}