/// <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 )
{
BinaryFile binaryFile;
var rockContext = new RockContext();
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
int binaryFileId = int.Parse( hfBinaryFileId.Value );
if ( binaryFileId == 0 )
{
binaryFile = new BinaryFile();
binaryFileService.Add( binaryFile );
}
else
{
binaryFile = binaryFileService.Get( binaryFileId );
}
// if a new file was uploaded, copy the uploaded file to this binaryFile (uploaded files are always new temporary binaryFiles)
if ( fsFile.BinaryFileId != binaryFile.Id)
{
var uploadedBinaryFile = binaryFileService.Get(fsFile.BinaryFileId ?? 0);
if (uploadedBinaryFile != null)
{
binaryFile.BinaryFileTypeId = uploadedBinaryFile.BinaryFileTypeId;
binaryFile.ContentStream = uploadedBinaryFile.ContentStream;
}
}
binaryFile.IsTemporary = false;
binaryFile.FileName = tbName.Text;
binaryFile.Description = tbDescription.Text;
binaryFile.MimeType = tbMimeType.Text;
binaryFile.BinaryFileTypeId = ddlBinaryFileType.SelectedValueAsInt();
binaryFile.LoadAttributes( rockContext );
Rock.Attribute.Helper.GetEditValues( phAttributes, binaryFile );
if ( !Page.IsValid )
{
return;
}
if ( !binaryFile.IsValid )
{
// Controls will render the error messages
return;
}
rockContext.WrapTransaction( () =>
{
foreach ( var id in OrphanedBinaryFileIdList )
{
var tempBinaryFile = binaryFileService.Get( id );
if ( tempBinaryFile != null && tempBinaryFile.IsTemporary )
{
binaryFileService.Delete( tempBinaryFile );
}
}
rockContext.SaveChanges();
binaryFile.SaveAttributeValues( rockContext );
} );
NavigateToParentPage();
}
/// <summary>
/// Cleanups the temporary binary files.
/// </summary>
private void CleanupTemporaryBinaryFiles()
{
var binaryFileRockContext = new Rock.Data.RockContext();
// clean out any temporary binary files
BinaryFileService binaryFileService = new BinaryFileService( binaryFileRockContext );
foreach ( var binaryFile in binaryFileService.Queryable().Where( bf => bf.IsTemporary == true ).ToList() )
{
if ( binaryFile.ModifiedDateTime < RockDateTime.Now.AddDays( -1 ) )
{
binaryFileService.Delete( binaryFile );
binaryFileRockContext.SaveChanges();
}
}
}
/// <summary>
/// Handles the Delete event of the gBinaryFile 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 gBinaryFile_Delete( object sender, RowEventArgs e )
{
var rockContext = new RockContext();
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
BinaryFile binaryFile = binaryFileService.Get( e.RowKeyId );
if ( binaryFile != null )
{
string errorMessage;
if ( !binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
mdGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
BindGrid();
}
/// <summary>
/// Executes this instance.
/// </summary>
public void Execute()
{
using ( var rockContext = new RockContext() )
{
var binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( BinaryFileGuid );
if ( binaryFile != null )
{
string guidAsString = BinaryFileGuid.ToString();
// If any attribute still has this file as a default value, don't delete it
if ( new AttributeService( rockContext ).Queryable().Any( a => a.DefaultValue == guidAsString ) )
{
return;
}
// If any attribute value still has this file as a value, don't delete it
if ( new AttributeValueService( rockContext ).Queryable().Any( a => a.Value == guidAsString ) )
{
return;
}
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
}
}
/// <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 );
}
}
}
/// <summary>
/// Handles the Delete event of the gBinaryFile 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 gBinaryFile_Delete( object sender, RowEventArgs e )
{
var rockContext = new RockContext();
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
BinaryFile binaryFile = binaryFileService.Get( e.RowKeyId );
if ( binaryFile != null )
{
string errorMessage;
if ( !binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
mdGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
Guid guid = binaryFile.Guid;
bool clearDeviceCache = binaryFile.BinaryFileType.Guid.Equals( Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL.AsGuid() );
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
if ( clearDeviceCache )
{
Rock.CheckIn.KioskDevice.FlushAll();
Rock.CheckIn.KioskLabel.Flush( guid );
}
}
BindGrid();
}
/// <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 )
{
ConnectionOpportunity connectionOpportunity = null;
using ( RockContext rockContext = new RockContext() )
{
int? groupTypeId = ddlGroupType.SelectedValueAsInt();
if ( groupTypeId.HasValue && GroupsState.Any( g => g.Group.GroupTypeId != groupTypeId.Value ) )
{
var groupType = new GroupTypeService( rockContext ).Get( groupTypeId.Value );
if ( groupType != null )
{
nbInvalidGroupTypes.Text = string.Format( "<p>One or more of the selected groups is not a <strong>{0}</strong> type. Please select groups that have a group type of <strong>{0}</strong>.", groupType.Name );
nbInvalidGroupTypes.Visible = true;
return;
}
}
ConnectionOpportunityService connectionOpportunityService = new ConnectionOpportunityService( rockContext );
EventCalendarItemService eventCalendarItemService = new EventCalendarItemService( rockContext );
ConnectionWorkflowService connectionWorkflowService = new ConnectionWorkflowService( rockContext );
ConnectionOpportunityConnectorGroupService connectionOpportunityConnectorGroupsService = new ConnectionOpportunityConnectorGroupService( rockContext );
ConnectionOpportunityCampusService connectionOpportunityCampusService = new ConnectionOpportunityCampusService( rockContext );
ConnectionOpportunityGroupService connectionOpportunityGroupService = new ConnectionOpportunityGroupService( rockContext );
int connectionOpportunityId = hfConnectionOpportunityId.ValueAsInt();
if ( connectionOpportunityId != 0 )
{
connectionOpportunity = connectionOpportunityService
.Queryable( "ConnectionOpportunityGroups, ConnectionWorkflows" )
.Where( ei => ei.Id == connectionOpportunityId )
.FirstOrDefault();
}
if ( connectionOpportunity == null )
{
connectionOpportunity = new ConnectionOpportunity();
connectionOpportunity.Name = string.Empty;
connectionOpportunity.ConnectionTypeId = PageParameter( "ConnectionTypeId" ).AsInteger();
connectionOpportunityService.Add( connectionOpportunity );
}
connectionOpportunity.Name = tbName.Text;
connectionOpportunity.Description = tbDescription.Text;
connectionOpportunity.IsActive = cbIsActive.Checked;
connectionOpportunity.PublicName = tbPublicName.Text;
connectionOpportunity.IconCssClass = tbIconCssClass.Text;
connectionOpportunity.GroupTypeId = ddlGroupType.SelectedValue.AsInteger();
connectionOpportunity.GroupMemberRoleId = ddlGroupRole.SelectedValue.AsInteger();
connectionOpportunity.GroupMemberStatus = ddlGroupMemberStatus.SelectedValueAsEnum<GroupMemberStatus>();
int? orphanedPhotoId = null;
if ( imgupPhoto.BinaryFileId != null )
{
if ( connectionOpportunity.PhotoId != imgupPhoto.BinaryFileId )
{
orphanedPhotoId = connectionOpportunity.PhotoId;
}
connectionOpportunity.PhotoId = imgupPhoto.BinaryFileId.Value;
}
// remove any workflows that removed in the UI
var uiWorkflows = WorkflowsState.Where( w => w.ConnectionTypeId == null ).Select( l => l.Guid );
foreach ( var connectionOpportunityWorkflow in connectionOpportunity.ConnectionWorkflows.Where( l => !uiWorkflows.Contains( l.Guid ) ).ToList() )
{
connectionOpportunity.ConnectionWorkflows.Remove( connectionOpportunityWorkflow );
connectionWorkflowService.Delete( connectionOpportunityWorkflow );
}
// Add or Update workflows from the UI
foreach ( ConnectionWorkflow connectionOpportunityWorkflowState in WorkflowsState.Where( w => w.ConnectionTypeId == null ) )
{
ConnectionWorkflow connectionOpportunityWorkflow = connectionOpportunity.ConnectionWorkflows.Where( a => a.Guid == connectionOpportunityWorkflowState.Guid ).FirstOrDefault();
if ( connectionOpportunityWorkflow == null )
{
connectionOpportunityWorkflow = new ConnectionWorkflow();
connectionOpportunity.ConnectionWorkflows.Add( connectionOpportunityWorkflow );
}
connectionOpportunityWorkflow.CopyPropertiesFrom( connectionOpportunityWorkflowState );
connectionOpportunityWorkflow.ConnectionOpportunityId = connectionOpportunity.Id;
}
// remove any group campuses that removed in the UI
var uiGroupCampuses = GroupCampusesState.Select( l => l.Guid );
foreach ( var connectionOpportunityConnectorGroups in connectionOpportunity.ConnectionOpportunityConnectorGroups.Where( l => !uiGroupCampuses.Contains( l.Guid ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityConnectorGroups.Remove( connectionOpportunityConnectorGroups );
connectionOpportunityConnectorGroupsService.Delete( connectionOpportunityConnectorGroups );
}
// Add or Update group campuses from the UI
foreach ( var connectionOpportunityConnectorGroupsState in GroupCampusesState )
{
ConnectionOpportunityConnectorGroup connectionOpportunityConnectorGroups = connectionOpportunity.ConnectionOpportunityConnectorGroups.Where( a => a.Guid == connectionOpportunityConnectorGroupsState.Guid ).FirstOrDefault();
if ( connectionOpportunityConnectorGroups == null )
{
connectionOpportunityConnectorGroups = new ConnectionOpportunityConnectorGroup();
connectionOpportunity.ConnectionOpportunityConnectorGroups.Add( connectionOpportunityConnectorGroups );
}
connectionOpportunityConnectorGroups.CopyPropertiesFrom( connectionOpportunityConnectorGroupsState );
}
// remove any campuses that removed in the UI
var uiCampuses = cblCampus.SelectedValuesAsInt;
foreach ( var connectionOpportunityCampus in connectionOpportunity.ConnectionOpportunityCampuses.Where( c => !uiCampuses.Contains( c.CampusId ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityCampuses.Remove( connectionOpportunityCampus );
connectionOpportunityCampusService.Delete( connectionOpportunityCampus );
}
// Add or Update campuses from the UI
foreach ( var campusId in uiCampuses )
{
ConnectionOpportunityCampus connectionOpportunityCampus = connectionOpportunity.ConnectionOpportunityCampuses.Where( c => c.CampusId == campusId ).FirstOrDefault();
if ( connectionOpportunityCampus == null )
{
connectionOpportunityCampus = new ConnectionOpportunityCampus();
connectionOpportunity.ConnectionOpportunityCampuses.Add( connectionOpportunityCampus );
}
connectionOpportunityCampus.CampusId = campusId;
}
// Remove any groups that were removed in the UI
var uiGroups = GroupsState.Select( r => r.Guid );
foreach ( var connectionOpportunityGroup in connectionOpportunity.ConnectionOpportunityGroups.Where( r => !uiGroups.Contains( r.Guid ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityGroups.Remove( connectionOpportunityGroup );
connectionOpportunityGroupService.Delete( connectionOpportunityGroup );
}
// Add or Update groups from the UI
foreach ( var connectionOpportunityGroupState in GroupsState )
{
ConnectionOpportunityGroup connectionOpportunityGroup = connectionOpportunity.ConnectionOpportunityGroups.Where( a => a.Guid == connectionOpportunityGroupState.Guid ).FirstOrDefault();
if ( connectionOpportunityGroup == null )
{
connectionOpportunityGroup = new ConnectionOpportunityGroup();
connectionOpportunity.ConnectionOpportunityGroups.Add( connectionOpportunityGroup );
}
connectionOpportunityGroup.CopyPropertiesFrom( connectionOpportunityGroupState );
}
connectionOpportunity.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phAttributes, connectionOpportunity );
if ( !Page.IsValid )
{
return;
}
if ( !connectionOpportunity.IsValid )
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
connectionOpportunity.SaveAttributeValues( rockContext );
if ( orphanedPhotoId.HasValue )
{
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( orphanedPhotoId.Value );
if ( binaryFile != null )
{
string errorMessage;
if ( binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
}
}
} );
var qryParams = new Dictionary<string, string>();
qryParams["ConnectionTypeId"] = PageParameter( "ConnectionTypeId" );
NavigateToParentPage( qryParams );
}
}
/// <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 );
NoteService noteService = new NoteService( rockContext );
AuthService authService = new AuthService( rockContext );
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 );
// 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 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 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 ) )
{
personAliasService.Delete( alias );
}
//foreach ( var relationship in person.Gro)
// 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 );
}
}
//rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
// delete all member photos
foreach ( var photo in binaryFileService.GetByIds( photoIds ) )
{
binaryFileService.Delete( photo );
}
DeleteGroupAndMemberData( family, rockContext );
}
}
}
/// <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 txnService = new FinancialTransactionService( rockContext );
var txnDetailService = new FinancialTransactionDetailService( rockContext );
var txnImageService = new FinancialTransactionImageService( rockContext );
var binaryFileService = new BinaryFileService( rockContext );
FinancialTransaction txn = null;
int? txnId = hfTransactionId.Value.AsIntegerOrNull();
int? batchId = hfBatchId.Value.AsIntegerOrNull();
if ( txnId.HasValue )
{
txn = txnService.Get( txnId.Value );
}
if ( txn == null )
{
txn = new FinancialTransaction();
txnService.Add( txn );
txn.BatchId = batchId;
}
if ( txn != null )
{
if ( ppAuthorizedPerson.PersonId.HasValue )
{
txn.AuthorizedPersonAliasId = ppAuthorizedPerson.PersonAliasId;
}
txn.TransactionDateTime = dtTransactionDateTime.SelectedDateTime;
txn.TransactionTypeValueId = ddlTransactionType.SelectedValue.AsInteger();
txn.SourceTypeValueId = ddlSourceType.SelectedValueAsInt();
Guid? gatewayGuid = cpPaymentGateway.SelectedValueAsGuid();
if ( gatewayGuid.HasValue )
{
var gatewayEntity = EntityTypeCache.Read( gatewayGuid.Value );
if ( gatewayEntity != null )
{
txn.GatewayEntityTypeId = gatewayEntity.Id;
}
else
{
txn.GatewayEntityTypeId = null;
}
}
else
{
txn.GatewayEntityTypeId = null;
}
txn.TransactionCode = tbTransactionCode.Text;
txn.CurrencyTypeValueId = ddlCurrencyType.SelectedValueAsInt();
txn.CreditCardTypeValueId = ddlCreditCardType.SelectedValueAsInt();
txn.Summary = tbSummary.Text;
if ( !Page.IsValid || !txn.IsValid )
{
return;
}
foreach ( var txnDetail in TransactionDetailsState )
{
if ( !txnDetail.IsValid )
{
return;
}
}
rockContext.WrapTransaction( () =>
{
// Save the transaction
rockContext.SaveChanges();
// Delete any transaction details that were removed
var txnDetailsInDB = txnDetailService.Queryable().Where( a => a.TransactionId.Equals( txn.Id ) ).ToList();
var deletedDetails = from txnDetail in txnDetailsInDB
where !TransactionDetailsState.Select( d => d.Guid ).Contains( txnDetail.Guid )
select txnDetail;
deletedDetails.ToList().ForEach( txnDetail =>
{
txnDetailService.Delete( txnDetail );
} );
rockContext.SaveChanges();
// Save Transaction Details
foreach ( var editorTxnDetail in TransactionDetailsState )
{
// Add or Update the activity type
var txnDetail = txn.TransactionDetails.FirstOrDefault( d => d.Guid.Equals( editorTxnDetail.Guid ) );
if ( txnDetail == null )
{
txnDetail = new FinancialTransactionDetail();
txnDetail.Guid = editorTxnDetail.Guid;
txn.TransactionDetails.Add( txnDetail );
}
txnDetail.AccountId = editorTxnDetail.AccountId;
txnDetail.Amount = UseSimpleAccountMode ? tbSingleAccountAmount.Text.AsDecimal() : editorTxnDetail.Amount;
txnDetail.Summary = editorTxnDetail.Summary;
}
rockContext.SaveChanges();
// Delete any transaction images that were removed
var orphanedBinaryFileIds = new List<int>();
var txnImagesInDB = txnImageService.Queryable().Where( a => a.TransactionId.Equals( txn.Id ) ).ToList();
foreach ( var txnImage in txnImagesInDB.Where( i => !TransactionImagesState.Contains( i.BinaryFileId ) ) )
{
orphanedBinaryFileIds.Add( txnImage.BinaryFileId );
txnImageService.Delete( txnImage );
}
// Save Transaction Images
int imageOrder = 0;
foreach ( var binaryFileId in TransactionImagesState )
{
// Add or Update the activity type
var txnImage = txnImagesInDB.FirstOrDefault( i => i.BinaryFileId == binaryFileId );
if ( txnImage == null )
{
txnImage = new FinancialTransactionImage();
txnImage.TransactionId = txn.Id;
txn.Images.Add( txnImage );
}
txnImage.BinaryFileId = binaryFileId;
txnImage.Order = imageOrder;
imageOrder++;
}
rockContext.SaveChanges();
// Make sure updated binary files are not temporary
foreach ( var binaryFile in binaryFileService.Queryable().Where( f => TransactionImagesState.Contains( f.Id ) ) )
{
binaryFile.IsTemporary = false;
}
// Delete any orphaned images
foreach ( var binaryFile in binaryFileService.Queryable().Where( f => orphanedBinaryFileIds.Contains( f.Id ) ) )
{
binaryFileService.Delete( binaryFile );
}
rockContext.SaveChanges();
} );
// Save selected options to session state in order to prefill values for next added txn
Session["NewTxnDefault_BatchId"] = txn.BatchId;
Session["NewTxnDefault_TransactionDateTime"] = txn.TransactionDateTime;
Session["NewTxnDefault_TransactionType"] = txn.TransactionTypeValueId;
Session["NewTxnDefault_SourceType"] = txn.SourceTypeValueId;
Session["NewTxnDefault_CurrencyType"] = txn.CurrencyTypeValueId;
Session["NewTxnDefault_CreditCardType"] = txn.CreditCardTypeValueId;
if ( TransactionDetailsState.Count() == 1 )
{
Session["NewTxnDefault_Account"] = TransactionDetailsState.First().AccountId;
}
else
{
Session.Remove("NewTxnDefault_Account");
}
// Requery the batch to support EF navigation properties
var savedTxn = GetTransaction( txn.Id );
ShowReadOnlyDetails( savedTxn );
}
}
/// <summary>
/// Job that executes routine Rock cleanup tasks
///
/// Called by the <see cref="IScheduler" /> when a
/// <see cref="ITrigger" /> fires that is associated with
/// the <see cref="IJob" />.
/// </summary>
public virtual void Execute( IJobExecutionContext context )
{
var rockContext = new Rock.Data.RockContext();
// get the job map
JobDataMap dataMap = context.JobDetail.JobDataMap;
// delete accounts that have not been confirmed in X hours
int? userExpireHours = dataMap.GetString( "HoursKeepUnconfirmedAccounts" ).AsIntegerOrNull();
if ( userExpireHours.HasValue )
{
DateTime userAccountExpireDate = RockDateTime.Now.Add( new TimeSpan( userExpireHours.Value * -1, 0, 0 ) );
var userLoginService = new UserLoginService(rockContext);
foreach ( var user in userLoginService.Queryable().Where( u => u.IsConfirmed == false && ( u.CreatedDateTime ?? DateTime.MinValue ) < userAccountExpireDate ).ToList() )
{
userLoginService.Delete( user );
}
rockContext.SaveChanges();
}
// purge exception log
int? exceptionExpireDays = dataMap.GetString( "DaysKeepExceptions" ).AsIntegerOrNull();
if ( exceptionExpireDays.HasValue )
{
DateTime exceptionExpireDate = RockDateTime.Now.Add( new TimeSpan( exceptionExpireDays.Value * -1, 0, 0, 0 ) );
ExceptionLogService exceptionLogService = new ExceptionLogService( rockContext );
foreach ( var exception in exceptionLogService.Queryable().Where( e => e.CreatedDateTime.HasValue && e.CreatedDateTime < exceptionExpireDate ).ToList() )
{
exceptionLogService.Delete( exception );
}
rockContext.SaveChanges();
}
// purge audit log
int? auditExpireDays = dataMap.GetString( "AuditLogExpirationDays" ).AsIntegerOrNull();
if ( auditExpireDays.HasValue )
{
DateTime auditExpireDate = RockDateTime.Now.Add( new TimeSpan( auditExpireDays.Value * -1, 0, 0, 0 ) );
AuditService auditService = new AuditService(rockContext);
foreach ( var audit in auditService.Queryable().Where( a => a.DateTime < auditExpireDate ).ToList() )
{
auditService.Delete( audit );
}
rockContext.SaveChanges();
}
// clean the cached file directory
// get the attributes
string cacheDirectoryPath = dataMap.GetString( "BaseCacheDirectory" );
int? cacheExpirationDays = dataMap.GetString( "DaysKeepCachedFiles" ).AsIntegerOrNull();
if ( cacheExpirationDays.HasValue )
{
DateTime cacheExpirationDate = RockDateTime.Now.Add( new TimeSpan( cacheExpirationDays.Value * -1, 0, 0, 0 ) );
// if job is being run by the IIS scheduler and path is not null
if ( context.Scheduler.SchedulerName == "RockSchedulerIIS" && !string.IsNullOrEmpty( cacheDirectoryPath ) )
{
// get the physical path of the cache directory
cacheDirectoryPath = System.Web.Hosting.HostingEnvironment.MapPath( cacheDirectoryPath );
}
// if directory is not blank and cache expiration date not in the future
if ( !string.IsNullOrEmpty( cacheDirectoryPath ) && cacheExpirationDate <= RockDateTime.Now )
{
// Clean cache directory
CleanCacheDirectory( cacheDirectoryPath, cacheExpirationDate );
}
}
// clean out any temporary binary files
BinaryFileService binaryFileService = new BinaryFileService(rockContext);
foreach ( var binaryFile in binaryFileService.Queryable().Where( bf => bf.IsTemporary == true ).ToList() )
{
if ( binaryFile.ModifiedDateTime < RockDateTime.Now.AddDays( -1 ) )
{
binaryFileService.Delete( binaryFile );
}
}
rockContext.SaveChanges();
// Add any missing person aliases
PersonService personService = new PersonService(rockContext);
foreach ( var person in personService.Queryable( "Aliases" )
.Where( p => !p.Aliases.Any() )
.Take( 300 ) )
{
person.Aliases.Add( new PersonAlias { AliasPersonId = person.Id, AliasPersonGuid = person.Guid } );
}
rockContext.SaveChanges();
// Add any missing metaphones
int namesToProcess = dataMap.GetString( "MaxMetaphoneNames" ).AsInteger();
if ( namesToProcess > 0 )
{
var firstNameQry = personService.Queryable().Select( p => p.FirstName );
var nickNameQry = personService.Queryable().Select( p => p.NickName );
var lastNameQry = personService.Queryable().Select( p => p.LastName );
var nameQry = firstNameQry.Union( nickNameQry.Union( lastNameQry ) );
var metaphones = rockContext.Metaphones;
var existingNames = metaphones.Select( m => m.Name ).Distinct();
// Get the names that have not yet been processed
var namesToUpdate = nameQry
.Where( n => !existingNames.Contains( n ) )
.Take( namesToProcess )
.ToList();
foreach ( string name in namesToUpdate )
{
string mp1 = string.Empty;
string mp2 = string.Empty;
Rock.Utility.DoubleMetaphone.doubleMetaphone( name, ref mp1, ref mp2 );
var metaphone = new Metaphone();
metaphone.Name = name;
metaphone.Metaphone1 = mp1;
metaphone.Metaphone2 = mp2;
metaphones.Add( metaphone );
}
rockContext.SaveChanges();
}
}
/// <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 )
{
ConnectionOpportunity connectionOpportunity = null;
using ( RockContext rockContext = new RockContext() )
{
if ( !ValidPlacementGroups() )
{
return;
}
ConnectionOpportunityService connectionOpportunityService = new ConnectionOpportunityService( rockContext );
EventCalendarItemService eventCalendarItemService = new EventCalendarItemService( rockContext );
ConnectionWorkflowService connectionWorkflowService = new ConnectionWorkflowService( rockContext );
ConnectionRequestWorkflowService connectionRequestWorkflowService = new ConnectionRequestWorkflowService( rockContext );
ConnectionOpportunityConnectorGroupService connectionOpportunityConnectorGroupsService = new ConnectionOpportunityConnectorGroupService( rockContext );
ConnectionOpportunityCampusService connectionOpportunityCampusService = new ConnectionOpportunityCampusService( rockContext );
ConnectionOpportunityGroupConfigService connectionOpportunityGroupConfigService = new ConnectionOpportunityGroupConfigService( rockContext );
ConnectionOpportunityGroupService connectionOpportunityGroupService = new ConnectionOpportunityGroupService( rockContext );
int connectionOpportunityId = hfConnectionOpportunityId.ValueAsInt();
if ( connectionOpportunityId != 0 )
{
connectionOpportunity = connectionOpportunityService
.Queryable( "ConnectionOpportunityGroups, ConnectionWorkflows" )
.Where( ei => ei.Id == connectionOpportunityId )
.FirstOrDefault();
}
if ( connectionOpportunity == null )
{
connectionOpportunity = new ConnectionOpportunity();
connectionOpportunity.Name = string.Empty;
connectionOpportunity.ConnectionTypeId = PageParameter( "ConnectionTypeId" ).AsInteger();
connectionOpportunityService.Add( connectionOpportunity );
}
connectionOpportunity.Name = tbName.Text;
connectionOpportunity.Summary = htmlSummary.Text;
connectionOpportunity.Description = htmlDescription.Text;
connectionOpportunity.IsActive = cbIsActive.Checked;
connectionOpportunity.PublicName = tbPublicName.Text;
connectionOpportunity.IconCssClass = tbIconCssClass.Text;
int? orphanedPhotoId = null;
if ( imgupPhoto.BinaryFileId != null )
{
if ( connectionOpportunity.PhotoId != imgupPhoto.BinaryFileId )
{
orphanedPhotoId = connectionOpportunity.PhotoId;
}
connectionOpportunity.PhotoId = imgupPhoto.BinaryFileId.Value;
}
// remove any workflows that removed in the UI
var uiWorkflows = WorkflowsState.Where( w => w.ConnectionTypeId == null ).Select( l => l.Guid );
foreach ( var connectionWorkflow in connectionOpportunity.ConnectionWorkflows.Where( l => !uiWorkflows.Contains( l.Guid ) ).ToList() )
{
foreach( var requestWorkflow in connectionRequestWorkflowService.Queryable()
.Where( w => w.ConnectionWorkflowId == connectionWorkflow.Id ) )
{
connectionRequestWorkflowService.Delete( requestWorkflow );
}
connectionOpportunity.ConnectionWorkflows.Remove( connectionWorkflow );
connectionWorkflowService.Delete( connectionWorkflow );
}
// Add or Update workflows from the UI
foreach ( var workflowTypeStateObj in WorkflowsState.Where( w => w.ConnectionTypeId == null ) )
{
ConnectionWorkflow connectionOpportunityWorkflow = connectionOpportunity.ConnectionWorkflows.Where( a => a.Guid == workflowTypeStateObj.Guid ).FirstOrDefault();
if ( connectionOpportunityWorkflow == null )
{
connectionOpportunityWorkflow = new ConnectionWorkflow();
connectionOpportunity.ConnectionWorkflows.Add( connectionOpportunityWorkflow );
}
connectionOpportunityWorkflow.Id = workflowTypeStateObj.Id;
connectionOpportunityWorkflow.Guid = workflowTypeStateObj.Guid;
connectionOpportunityWorkflow.ConnectionTypeId = workflowTypeStateObj.ConnectionTypeId;
connectionOpportunityWorkflow.WorkflowTypeId = workflowTypeStateObj.WorkflowTypeId;
connectionOpportunityWorkflow.TriggerType = workflowTypeStateObj.TriggerType;
connectionOpportunityWorkflow.QualifierValue = workflowTypeStateObj.QualifierValue;
connectionOpportunityWorkflow.ConnectionOpportunityId = connectionOpportunity.Id;
}
// remove any group campuses that removed in the UI
var uiConnectorGroups = ConnectorGroupsState.Select( l => l.Guid );
foreach ( var connectionOpportunityConnectorGroups in connectionOpportunity.ConnectionOpportunityConnectorGroups.Where( l => !uiConnectorGroups.Contains( l.Guid ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityConnectorGroups.Remove( connectionOpportunityConnectorGroups );
connectionOpportunityConnectorGroupsService.Delete( connectionOpportunityConnectorGroups );
}
// Add or Update group campuses from the UI
foreach ( var groupStateObj in ConnectorGroupsState )
{
ConnectionOpportunityConnectorGroup connectionOpportunityConnectorGroup = connectionOpportunity.ConnectionOpportunityConnectorGroups.Where( a => a.Guid == groupStateObj.Guid ).FirstOrDefault();
if ( connectionOpportunityConnectorGroup == null )
{
connectionOpportunityConnectorGroup = new ConnectionOpportunityConnectorGroup();
connectionOpportunity.ConnectionOpportunityConnectorGroups.Add( connectionOpportunityConnectorGroup );
}
connectionOpportunityConnectorGroup.CampusId = groupStateObj.CampusId;
connectionOpportunityConnectorGroup.ConnectorGroupId = groupStateObj.GroupId;
connectionOpportunityConnectorGroup.ConnectionOpportunityId = connectionOpportunity.Id;
}
// remove any campuses that removed in the UI
var uiCampuses = cblSelectedItemsAsInt( cblCampus );
foreach ( var connectionOpportunityCampus in connectionOpportunity.ConnectionOpportunityCampuses.Where( c => !uiCampuses.Contains( c.CampusId ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityCampuses.Remove( connectionOpportunityCampus );
connectionOpportunityCampusService.Delete( connectionOpportunityCampus );
}
// Add or Update campuses from the UI
foreach ( var campusId in uiCampuses )
{
ConnectionOpportunityCampus connectionOpportunityCampus = connectionOpportunity.ConnectionOpportunityCampuses.Where( c => c.CampusId == campusId ).FirstOrDefault();
if ( connectionOpportunityCampus == null )
{
connectionOpportunityCampus = new ConnectionOpportunityCampus();
connectionOpportunity.ConnectionOpportunityCampuses.Add( connectionOpportunityCampus );
}
connectionOpportunityCampus.CampusId = campusId;
connectionOpportunityCampus.DefaultConnectorPersonAliasId = DefaultConnectors.ContainsKey( campusId ) ? DefaultConnectors[campusId] : (int?)null;
}
// remove any group configs that were removed in the UI
var uiGroupConfigs = GroupConfigsState.Select( r => r.Guid );
foreach ( var connectionOpportunityGroupConfig in connectionOpportunity.ConnectionOpportunityGroupConfigs.Where( r => !uiGroupConfigs.Contains( r.Guid ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityGroupConfigs.Remove( connectionOpportunityGroupConfig );
connectionOpportunityGroupConfigService.Delete( connectionOpportunityGroupConfig );
}
// Add or Update group configs from the UI
foreach ( var groupConfigStateObj in GroupConfigsState )
{
ConnectionOpportunityGroupConfig connectionOpportunityGroupConfig = connectionOpportunity.ConnectionOpportunityGroupConfigs.Where( a => a.Guid == groupConfigStateObj.Guid ).FirstOrDefault();
if ( connectionOpportunityGroupConfig == null )
{
connectionOpportunityGroupConfig = new ConnectionOpportunityGroupConfig();
connectionOpportunity.ConnectionOpportunityGroupConfigs.Add( connectionOpportunityGroupConfig );
}
connectionOpportunityGroupConfig.GroupTypeId = groupConfigStateObj.GroupTypeId;
connectionOpportunityGroupConfig.GroupMemberRoleId = groupConfigStateObj.GroupMemberRoleId;
connectionOpportunityGroupConfig.GroupMemberStatus = groupConfigStateObj.GroupMemberStatus;
connectionOpportunityGroupConfig.UseAllGroupsOfType = groupConfigStateObj.UseAllGroupsOfType;
connectionOpportunityGroupConfig.ConnectionOpportunityId = connectionOpportunity.Id;
}
// Remove any groups that were removed in the UI
var uiGroups = GroupsState.Select( r => r.Guid );
foreach ( var connectionOpportunityGroup in connectionOpportunity.ConnectionOpportunityGroups.Where( r => !uiGroups.Contains( r.Guid ) ).ToList() )
{
connectionOpportunity.ConnectionOpportunityGroups.Remove( connectionOpportunityGroup );
connectionOpportunityGroupService.Delete( connectionOpportunityGroup );
}
// Add or Update groups from the UI
foreach ( var groupStateObj in GroupsState )
{
ConnectionOpportunityGroup connectionOpportunityGroup = connectionOpportunity.ConnectionOpportunityGroups.Where( a => a.Guid == groupStateObj.Guid ).FirstOrDefault();
if ( connectionOpportunityGroup == null )
{
connectionOpportunityGroup = new ConnectionOpportunityGroup();
connectionOpportunity.ConnectionOpportunityGroups.Add( connectionOpportunityGroup );
}
connectionOpportunityGroup.GroupId = groupStateObj.GroupId;
connectionOpportunityGroup.ConnectionOpportunityId = connectionOpportunity.Id;
}
connectionOpportunity.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phAttributes, connectionOpportunity );
if ( !Page.IsValid )
{
return;
}
if ( !connectionOpportunity.IsValid )
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
connectionOpportunity.SaveAttributeValues( rockContext );
if ( orphanedPhotoId.HasValue )
{
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( orphanedPhotoId.Value );
if ( binaryFile != null )
{
string errorMessage;
if ( binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
}
}
} );
ConnectionWorkflowService.FlushCachedTriggers();
var qryParams = new Dictionary<string, string>();
qryParams["ConnectionTypeId"] = PageParameter( "ConnectionTypeId" );
NavigateToParentPage( qryParams );
}
}
/// <summary>
/// Handles the Delete event of the gBinaryFile 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 gBinaryFile_Delete( object sender, RowEventArgs e )
{
RockTransactionScope.WrapTransaction( () =>
{
BinaryFileService binaryFileService = new BinaryFileService();
BinaryFile binaryFile = binaryFileService.Get( (int)e.RowKeyValue );
if ( binaryFile != null )
{
string errorMessage;
if ( !binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
mdGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
binaryFileService.Delete( binaryFile, CurrentPersonId );
binaryFileService.Save( binaryFile, CurrentPersonId );
}
} );
BindGrid();
}
/// <summary>
/// Job that executes routine Rock cleanup tasks
///
/// Called by the <see cref="IScheduler" /> when a
/// <see cref="ITrigger" /> fires that is associated with
/// the <see cref="IJob" />.
/// </summary>
public virtual void Execute(IJobExecutionContext context)
{
// get the job map
JobDataMap dataMap = context.JobDetail.JobDataMap;
// delete accounts that have not been confirmed in X hours
int userExpireHours = Int32.Parse( dataMap.GetString( "HoursKeepUnconfirmedAccounts" ) );
DateTime userAccountExpireDate = DateTime.Now.Add( new TimeSpan( userExpireHours * -1,0,0 ) );
var userLoginService = new UserLoginService();
foreach (var user in userLoginService.Queryable().Where(u => u.IsConfirmed == false && u.CreationDateTime < userAccountExpireDate).ToList() )
{
userLoginService.Delete( user, null );
userLoginService.Save( user, null );
}
// purge exception log
int exceptionExpireDays = Int32.Parse( dataMap.GetString( "DaysKeepExceptions" ) );
DateTime exceptionExpireDate = DateTime.Now.Add( new TimeSpan( exceptionExpireDays * -1, 0, 0, 0 ) );
ExceptionLogService exceptionLogService = new ExceptionLogService();
foreach ( var exception in exceptionLogService.Queryable().Where( e => e.ExceptionDateTime < exceptionExpireDate ).ToList() )
{
exceptionLogService.Delete( exception, null );
exceptionLogService.Save( exception, null );
}
// purge audit log
int auditExpireDays = Int32.Parse( dataMap.GetString( "AuditLogExpirationDays" ) );
DateTime auditExpireDate = DateTime.Now.Add( new TimeSpan( auditExpireDays * -1, 0, 0, 0 ) );
AuditService auditService = new AuditService();
foreach( var audit in auditService.Queryable().Where( a => a.DateTime < auditExpireDate ).ToList() )
{
auditService.Delete( audit, null );
auditService.Save( audit, null );
}
// clean the cached file directory
//get the attributes
string cacheDirectoryPath = dataMap.GetString( "BaseCacheDirectory" );
int cacheExpirationDays = int.Parse( dataMap.GetString( "DaysKeepCachedFiles" ) );
DateTime cacheExpirationDate = DateTime.Now.Add( new TimeSpan( cacheExpirationDays * -1, 0, 0, 0 ) );
//if job is being run by the IIS scheduler and path is not null
if ( context.Scheduler.SchedulerName == "RockSchedulerIIS" && !String.IsNullOrEmpty( cacheDirectoryPath ) )
{
//get the physical path of the cache directory
cacheDirectoryPath = System.Web.Hosting.HostingEnvironment.MapPath( cacheDirectoryPath );
}
//if directory is not blank and cache expiration date not in the future
if ( !String.IsNullOrEmpty( cacheDirectoryPath ) && cacheExpirationDate <= DateTime.Now )
{
//Clean cache directory
CleanCacheDirectory( cacheDirectoryPath, cacheExpirationDate );
}
// clean out any temporary binary files
BinaryFileService binaryFileService = new BinaryFileService();
foreach( var binaryFile in binaryFileService.Queryable().Where( bf => bf.IsTemporary == true ).ToList() )
{
if ( binaryFile.LastModifiedDateTime < DateTime.Now.AddDays(-1) )
{
binaryFileService.Delete( binaryFile, null );
binaryFileService.Save( binaryFile, null );
}
}
}
/// <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 txnService = new FinancialTransactionService( rockContext );
var txnDetailService = new FinancialTransactionDetailService( rockContext );
var txnImageService = new FinancialTransactionImageService( rockContext );
var binaryFileService = new BinaryFileService( rockContext );
FinancialTransaction txn = null;
int? txnId = hfTransactionId.Value.AsIntegerOrNull();
int? batchId = hfBatchId.Value.AsIntegerOrNull();
var changes = new List<string>();
if ( txnId.HasValue )
{
txn = txnService.Get( txnId.Value );
}
if ( txn == null )
{
txn = new FinancialTransaction();
txnService.Add( txn );
txn.BatchId = batchId;
changes.Add( "Created transaction" );
}
if ( txn != null )
{
if ( txn.FinancialPaymentDetail == null )
{
txn.FinancialPaymentDetail = new FinancialPaymentDetail();
}
string newPerson = ppAuthorizedPerson.PersonName;
if ( batchId.HasValue )
{
if ( !txn.AuthorizedPersonAliasId.Equals( ppAuthorizedPerson.PersonAliasId ) )
{
string prevPerson = ( txn.AuthorizedPersonAlias != null && txn.AuthorizedPersonAlias.Person != null ) ?
txn.AuthorizedPersonAlias.Person.FullName : string.Empty;
History.EvaluateChange( changes, "Person", prevPerson, newPerson );
}
History.EvaluateChange( changes, "Date/Time", txn.TransactionDateTime, dtTransactionDateTime.SelectedDateTime );
History.EvaluateChange( changes, "Type", GetDefinedValue( txn.TransactionTypeValueId ), GetDefinedValue( ddlTransactionType.SelectedValue.AsInteger() ) );
History.EvaluateChange( changes, "Source", GetDefinedValue( txn.SourceTypeValueId ), GetDefinedValue( ddlSourceType.SelectedValueAsInt() ) );
if ( !txn.FinancialGatewayId.Equals( gpPaymentGateway.SelectedValueAsInt() ) )
{
History.EvaluateChange( changes, "Gateway", GetFinancialGatewayName( txn.FinancialGatewayId, rockContext ), GetFinancialGatewayName( gpPaymentGateway.SelectedValueAsInt(), rockContext ) );
}
History.EvaluateChange( changes, "Transaction Code", txn.TransactionCode, tbTransactionCode.Text );
History.EvaluateChange( changes, "Currency Type", GetDefinedValue( txn.FinancialPaymentDetail.CurrencyTypeValueId ), GetDefinedValue( ddlCurrencyType.SelectedValueAsInt() ) );
History.EvaluateChange( changes, "Credit Card Type", GetDefinedValue( txn.FinancialPaymentDetail.CreditCardTypeValueId ), GetDefinedValue( ddlCreditCardType.SelectedValueAsInt() ) );
History.EvaluateChange( changes, "Summary", txn.Summary, tbSummary.Text );
History.EvaluateChange( changes, "Is Refund", ( txn.RefundDetails != null ), cbIsRefund.Checked );
}
txn.AuthorizedPersonAliasId = ppAuthorizedPerson.PersonAliasId;
txn.TransactionDateTime = dtTransactionDateTime.SelectedDateTime;
txn.TransactionTypeValueId = ddlTransactionType.SelectedValue.AsInteger();
txn.SourceTypeValueId = ddlSourceType.SelectedValueAsInt();
txn.FinancialGatewayId = gpPaymentGateway.SelectedValueAsInt();
txn.TransactionCode = tbTransactionCode.Text;
txn.FinancialPaymentDetail.CurrencyTypeValueId = ddlCurrencyType.SelectedValueAsInt();
txn.FinancialPaymentDetail.CreditCardTypeValueId = ddlCreditCardType.SelectedValueAsInt();
txn.Summary = tbSummary.Text;
decimal totalAmount = TransactionDetailsState.Select( d => d.Amount ).ToList().Sum();
if ( cbIsRefund.Checked && totalAmount > 0 )
{
nbErrorMessage.Title = "Incorrect Refund Amount";
nbErrorMessage.Text = "<p>A refund should have a negative amount. Please unselect the refund option, or change amounts to be negative values.</p>";
nbErrorMessage.Visible = true;
return;
}
if ( cbIsRefund.Checked )
{
if ( txn.RefundDetails != null )
{
txn.RefundDetails = new FinancialTransactionRefund();
}
txn.RefundDetails.RefundReasonValueId = ddlRefundReasonEdit.SelectedValueAsId();
txn.RefundDetails.RefundReasonSummary = tbRefundSummaryEdit.Text;
}
if ( !Page.IsValid || !txn.IsValid )
{
return;
}
foreach ( var txnDetail in TransactionDetailsState )
{
if ( !txnDetail.IsValid )
{
return;
}
}
rockContext.WrapTransaction( () =>
{
// Save the transaction
rockContext.SaveChanges();
// Delete any transaction details that were removed
var txnDetailsInDB = txnDetailService.Queryable().Where( a => a.TransactionId.Equals( txn.Id ) ).ToList();
var deletedDetails = from txnDetail in txnDetailsInDB
where !TransactionDetailsState.Select( d => d.Guid ).Contains( txnDetail.Guid )
select txnDetail;
deletedDetails.ToList().ForEach( txnDetail =>
{
if ( batchId.HasValue )
{
History.EvaluateChange( changes, txnDetail.Account != null ? txnDetail.Account.Name : "Unknown", txnDetail.Amount.FormatAsCurrency(), string.Empty );
}
txnDetailService.Delete( txnDetail );
} );
// Save Transaction Details
foreach ( var editorTxnDetail in TransactionDetailsState )
{
string oldAccountName = string.Empty;
string newAccountName = string.Empty;
decimal oldAmount = 0.0M;
decimal newAmount = 0.0M;
// Add or Update the activity type
var txnDetail = txn.TransactionDetails.FirstOrDefault( d => d.Guid.Equals( editorTxnDetail.Guid ) );
if ( txnDetail != null )
{
oldAccountName = AccountName( txnDetail.AccountId );
oldAmount = txnDetail.Amount;
}
else
{
txnDetail = new FinancialTransactionDetail();
txnDetail.Guid = editorTxnDetail.Guid;
txn.TransactionDetails.Add( txnDetail );
}
newAccountName = AccountName( editorTxnDetail.AccountId );
newAmount = UseSimpleAccountMode ? tbSingleAccountAmount.Text.AsDecimal() : editorTxnDetail.Amount;
if ( batchId.HasValue )
{
if ( string.IsNullOrWhiteSpace(oldAccountName) )
{
History.EvaluateChange( changes, newAccountName, string.Empty, newAmount.FormatAsCurrency() );
}
else
{
if ( oldAccountName == newAccountName )
{
if ( oldAmount != newAmount )
{
History.EvaluateChange( changes, oldAccountName, oldAmount.FormatAsCurrency(), newAmount.FormatAsCurrency() );
}
}
else
{
History.EvaluateChange( changes, oldAccountName, oldAmount.FormatAsCurrency(), string.Empty );
History.EvaluateChange( changes, newAccountName, string.Empty, newAmount.FormatAsCurrency() );
}
}
}
txnDetail.AccountId = editorTxnDetail.AccountId;
txnDetail.Amount = newAmount;
txnDetail.Summary = editorTxnDetail.Summary;
if ( editorTxnDetail.AttributeValues != null )
{
txnDetail.LoadAttributes();
txnDetail.AttributeValues = editorTxnDetail.AttributeValues;
rockContext.SaveChanges();
txnDetail.SaveAttributeValues( rockContext );
}
}
// Delete any transaction images that were removed
var orphanedBinaryFileIds = new List<int>();
var txnImagesInDB = txnImageService.Queryable().Where( a => a.TransactionId.Equals( txn.Id ) ).ToList();
foreach ( var txnImage in txnImagesInDB.Where( i => !TransactionImagesState.Contains( i.BinaryFileId ) ) )
{
changes.Add( "Removed Image" );
orphanedBinaryFileIds.Add( txnImage.BinaryFileId );
txnImageService.Delete( txnImage );
}
// Save Transaction Images
int imageOrder = 0;
foreach ( var binaryFileId in TransactionImagesState )
{
// Add or Update the activity type
var txnImage = txnImagesInDB.FirstOrDefault( i => i.BinaryFileId == binaryFileId );
if ( txnImage == null )
{
changes.Add( "Added Image" );
txnImage = new FinancialTransactionImage();
txnImage.TransactionId = txn.Id;
txn.Images.Add( txnImage );
}
else
{
if ( txnImage.BinaryFileId != binaryFileId )
{
changes.Add( "Updated Image" );
}
}
txnImage.BinaryFileId = binaryFileId;
txnImage.Order = imageOrder;
imageOrder++;
}
rockContext.SaveChanges();
// Make sure updated binary files are not temporary
foreach ( var binaryFile in binaryFileService.Queryable().Where( f => TransactionImagesState.Contains( f.Id ) ) )
{
binaryFile.IsTemporary = false;
}
// Delete any orphaned images
foreach ( var binaryFile in binaryFileService.Queryable().Where( f => orphanedBinaryFileIds.Contains( f.Id ) ) )
{
binaryFileService.Delete( binaryFile );
}
// Update any attributes
txn.LoadAttributes(rockContext);
txn.FinancialPaymentDetail.LoadAttributes(rockContext);
Helper.GetEditValues(phAttributeEdits, txn);
Helper.GetEditValues(phPaymentAttributeEdits, txn.FinancialPaymentDetail);
// If the transaction is associated with a batch, update that batch's history
if ( batchId.HasValue )
{
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(),
batchId.Value,
changes,
!string.IsNullOrWhiteSpace( newPerson ) ? newPerson : string.Format( "Transaction Id:{0}", txn.Id ),
typeof( FinancialTransaction ),
txn.Id
);
}
rockContext.SaveChanges();
txn.SaveAttributeValues(rockContext);
txn.FinancialPaymentDetail.SaveAttributeValues(rockContext);
} );
// Save selected options to session state in order to prefill values for next added txn
Session["NewTxnDefault_BatchId"] = txn.BatchId;
Session["NewTxnDefault_TransactionDateTime"] = txn.TransactionDateTime;
Session["NewTxnDefault_TransactionType"] = txn.TransactionTypeValueId;
Session["NewTxnDefault_SourceType"] = txn.SourceTypeValueId;
Session["NewTxnDefault_CurrencyType"] = txn.FinancialPaymentDetail.CurrencyTypeValueId;
Session["NewTxnDefault_CreditCardType"] = txn.FinancialPaymentDetail.CreditCardTypeValueId;
if ( TransactionDetailsState.Count() == 1 )
{
Session["NewTxnDefault_Account"] = TransactionDetailsState.First().AccountId;
}
else
{
Session.Remove("NewTxnDefault_Account");
}
// Requery the batch to support EF navigation properties
var savedTxn = GetTransaction( txn.Id );
if ( savedTxn != null )
{
savedTxn.LoadAttributes();
savedTxn.FinancialPaymentDetail.LoadAttributes();
ShowReadOnlyDetails( savedTxn );
}
}
}
/// <summary>
/// Handles the Click event of the btnCancel 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 btnCancel_Click( object sender, EventArgs e )
{
if ( OrphanedBinaryFileIdList.Count > 0 )
{
var rockContext = new RockContext();
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
foreach ( var id in OrphanedBinaryFileIdList )
{
var tempBinaryFile = binaryFileService.Get( id );
if ( tempBinaryFile != null && tempBinaryFile.IsTemporary )
{
binaryFileService.Delete( tempBinaryFile );
}
}
rockContext.SaveChanges();
}
NavigateToParentPage();
}
/// <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 )
{
if ( IsUserAuthorized( Rock.Security.Authorization.EDIT ) )
{
var rockContext = new RockContext();
rockContext.WrapTransaction( () =>
{
var personService = new PersonService( rockContext );
var changes = new List<string>();
var person = personService.Get( Person.Id );
int? orphanedPhotoId = null;
if ( person.PhotoId != imgPhoto.BinaryFileId )
{
orphanedPhotoId = person.PhotoId;
person.PhotoId = imgPhoto.BinaryFileId;
if ( orphanedPhotoId.HasValue )
{
if ( person.PhotoId.HasValue )
{
changes.Add( "Modified the photo." );
}
else
{
changes.Add( "Deleted the photo." );
}
}
else if ( person.PhotoId.HasValue )
{
changes.Add( "Added a photo." );
}
}
int? newTitleId = ddlTitle.SelectedValueAsInt();
History.EvaluateChange( changes, "Title", DefinedValueCache.GetName( person.TitleValueId ), DefinedValueCache.GetName( newTitleId ) );
person.TitleValueId = newTitleId;
History.EvaluateChange( changes, "First Name", person.FirstName, tbFirstName.Text );
person.FirstName = tbFirstName.Text;
string nickName = string.IsNullOrWhiteSpace( tbNickName.Text ) ? tbFirstName.Text : tbNickName.Text;
History.EvaluateChange( changes, "Nick Name", person.NickName, nickName );
person.NickName = tbNickName.Text;
History.EvaluateChange( changes, "Middle Name", person.MiddleName, tbMiddleName.Text );
person.MiddleName = tbMiddleName.Text;
History.EvaluateChange( changes, "Last Name", person.LastName, tbLastName.Text );
person.LastName = tbLastName.Text;
int? newSuffixId = ddlSuffix.SelectedValueAsInt();
History.EvaluateChange( changes, "Suffix", DefinedValueCache.GetName( person.SuffixValueId ), DefinedValueCache.GetName( newSuffixId ) );
person.SuffixValueId = newSuffixId;
var birthMonth = person.BirthMonth;
var birthDay = person.BirthDay;
var birthYear = person.BirthYear;
var birthday = bpBirthDay.SelectedDate;
if ( birthday.HasValue )
{
// If setting a future birthdate, subtract a century until birthdate is not greater than today.
var today = RockDateTime.Today;
while ( birthday.Value.CompareTo( today ) > 0 )
{
birthday = birthday.Value.AddYears( -100 );
}
person.BirthMonth = birthday.Value.Month;
person.BirthDay = birthday.Value.Day;
if ( birthday.Value.Year != DateTime.MinValue.Year )
{
person.BirthYear = birthday.Value.Year;
}
else
{
person.BirthYear = null;
}
}
else
{
person.SetBirthDate( null );
}
History.EvaluateChange( changes, "Birth Month", birthMonth, person.BirthMonth );
History.EvaluateChange( changes, "Birth Day", birthDay, person.BirthDay );
History.EvaluateChange( changes, "Birth Year", birthYear, person.BirthYear );
int? graduationYear = null;
if ( ypGraduation.SelectedYear.HasValue )
{
graduationYear = ypGraduation.SelectedYear.Value;
}
History.EvaluateChange( changes, "Graduation Year", person.GraduationYear, graduationYear );
person.GraduationYear = graduationYear;
History.EvaluateChange( changes, "Anniversary Date", person.AnniversaryDate, dpAnniversaryDate.SelectedDate );
person.AnniversaryDate = dpAnniversaryDate.SelectedDate;
var newGender = rblGender.SelectedValue.ConvertToEnum<Gender>();
History.EvaluateChange( changes, "Gender", person.Gender, newGender );
person.Gender = newGender;
int? newMaritalStatusId = ddlMaritalStatus.SelectedValueAsInt();
History.EvaluateChange( changes, "Marital Status", DefinedValueCache.GetName( person.MaritalStatusValueId ), DefinedValueCache.GetName( newMaritalStatusId ) );
person.MaritalStatusValueId = newMaritalStatusId;
int? newConnectionStatusId = ddlConnectionStatus.SelectedValueAsInt();
History.EvaluateChange( changes, "Connection Status", DefinedValueCache.GetName( person.ConnectionStatusValueId ), DefinedValueCache.GetName( newConnectionStatusId ) );
person.ConnectionStatusValueId = newConnectionStatusId;
var phoneNumberTypeIds = new List<int>();
bool smsSelected = false;
foreach ( RepeaterItem item in rContactInfo.Items )
{
HiddenField hfPhoneType = item.FindControl( "hfPhoneType" ) as HiddenField;
PhoneNumberBox pnbPhone = item.FindControl( "pnbPhone" ) as PhoneNumberBox;
CheckBox cbUnlisted = item.FindControl( "cbUnlisted" ) as CheckBox;
CheckBox cbSms = item.FindControl( "cbSms" ) as CheckBox;
if ( hfPhoneType != null &&
pnbPhone != null &&
cbSms != null &&
cbUnlisted != null )
{
if ( !string.IsNullOrWhiteSpace( PhoneNumber.CleanNumber( pnbPhone.Number ) ) )
{
int phoneNumberTypeId;
if ( int.TryParse( hfPhoneType.Value, out phoneNumberTypeId ) )
{
var phoneNumber = person.PhoneNumbers.FirstOrDefault( n => n.NumberTypeValueId == phoneNumberTypeId );
string oldPhoneNumber = string.Empty;
if ( phoneNumber == null )
{
phoneNumber = new PhoneNumber { NumberTypeValueId = phoneNumberTypeId };
person.PhoneNumbers.Add( phoneNumber );
}
else
{
oldPhoneNumber = phoneNumber.NumberFormattedWithCountryCode;
}
phoneNumber.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode );
phoneNumber.Number = PhoneNumber.CleanNumber( pnbPhone.Number );
// Only allow one number to have SMS selected
if ( smsSelected )
{
phoneNumber.IsMessagingEnabled = false;
}
else
{
phoneNumber.IsMessagingEnabled = cbSms.Checked;
smsSelected = cbSms.Checked;
}
phoneNumber.IsUnlisted = cbUnlisted.Checked;
phoneNumberTypeIds.Add( phoneNumberTypeId );
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumberTypeId ) ),
oldPhoneNumber,
phoneNumber.NumberFormattedWithCountryCode );
}
}
}
}
// Remove any blank numbers
var phoneNumberService = new PhoneNumberService( rockContext );
foreach ( var phoneNumber in person.PhoneNumbers
.Where( n => n.NumberTypeValueId.HasValue && !phoneNumberTypeIds.Contains( n.NumberTypeValueId.Value ) )
.ToList() )
{
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumber.NumberTypeValueId ) ),
phoneNumber.ToString(),
string.Empty );
person.PhoneNumbers.Remove( phoneNumber );
phoneNumberService.Delete( phoneNumber );
}
History.EvaluateChange( changes, "Email", person.Email, tbEmail.Text );
person.Email = tbEmail.Text.Trim();
History.EvaluateChange( changes, "Email Active", person.IsEmailActive, cbIsEmailActive.Checked );
person.IsEmailActive = cbIsEmailActive.Checked;
var newEmailPreference = rblEmailPreference.SelectedValue.ConvertToEnum<EmailPreference>();
History.EvaluateChange( changes, "Email Preference", person.EmailPreference, newEmailPreference );
person.EmailPreference = newEmailPreference;
int? newGivingGroupId = ddlGivingGroup.SelectedValueAsId();
if ( person.GivingGroupId != newGivingGroupId )
{
string oldGivingGroupName = string.Empty;
if ( Person.GivingGroup != null )
{
oldGivingGroupName = GetFamilyNameWithFirstNames( Person.GivingGroup.Name, Person.GivingGroup.Members );
}
string newGivingGroupName = newGivingGroupId.HasValue ? ddlGivingGroup.Items.FindByValue( newGivingGroupId.Value.ToString() ).Text : string.Empty;
History.EvaluateChange( changes, "Giving Group", oldGivingGroupName, newGivingGroupName );
}
person.GivingGroupId = newGivingGroupId;
int? newRecordStatusId = ddlRecordStatus.SelectedValueAsInt();
History.EvaluateChange( changes, "Record Status", DefinedValueCache.GetName( person.RecordStatusValueId ), DefinedValueCache.GetName( newRecordStatusId ) );
person.RecordStatusValueId = newRecordStatusId;
int? newRecordStatusReasonId = null;
if ( person.RecordStatusValueId.HasValue && person.RecordStatusValueId.Value == DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ) ).Id )
{
newRecordStatusReasonId = ddlReason.SelectedValueAsInt();
}
History.EvaluateChange( changes, "Inactive Reason", DefinedValueCache.GetName( person.RecordStatusReasonValueId ), DefinedValueCache.GetName( newRecordStatusReasonId ) );
person.RecordStatusReasonValueId = newRecordStatusReasonId;
History.EvaluateChange( changes, "Inactive Reason Note", person.InactiveReasonNote, tbInactiveReasonNote.Text );
person.InactiveReasonNote = tbInactiveReasonNote.Text.Trim();
// Save any Removed/Added Previous Names
var personPreviousNameService = new PersonPreviousNameService( rockContext );
var databasePreviousNames = personPreviousNameService.Queryable().Where( a => a.PersonAlias.PersonId == person.Id ).ToList();
foreach ( var deletedPreviousName in databasePreviousNames.Where( a => !PersonPreviousNamesState.Any( p => p.Guid == a.Guid ) ) )
{
personPreviousNameService.Delete( deletedPreviousName );
History.EvaluateChange(
changes,
"Previous Name",
deletedPreviousName.ToString(),
string.Empty );
}
foreach ( var addedPreviousName in PersonPreviousNamesState.Where( a => !databasePreviousNames.Any( d => d.Guid == a.Guid ) ) )
{
addedPreviousName.PersonAliasId = person.PrimaryAliasId.Value;
personPreviousNameService.Add( addedPreviousName );
History.EvaluateChange(
changes,
"Previous Name",
string.Empty,
addedPreviousName.ToString() );
}
if ( person.IsValid )
{
if ( rockContext.SaveChanges() > 0 )
{
if ( changes.Any() )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
Person.Id,
changes );
}
if ( orphanedPhotoId.HasValue )
{
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( orphanedPhotoId.Value );
if ( binaryFile != null )
{
string errorMessage;
if ( binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
}
}
// if they used the ImageEditor, and cropped it, the uncropped file is still in BinaryFile. So clean it up
if ( imgPhoto.CropBinaryFileId.HasValue )
{
if ( imgPhoto.CropBinaryFileId != person.PhotoId )
{
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( imgPhoto.CropBinaryFileId.Value );
if ( binaryFile != null && binaryFile.IsTemporary )
{
string errorMessage;
if ( binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
}
}
}
}
Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
}
} );
}
}
/// <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 )
{
BinaryFile binaryFile;
var rockContext = new RockContext();
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
int? prevBinaryFileTypeId = null;
int binaryFileId = int.Parse( hfBinaryFileId.Value );
if ( binaryFileId == 0 )
{
binaryFile = new BinaryFile();
binaryFileService.Add( binaryFile );
}
else
{
binaryFile = binaryFileService.Get( binaryFileId );
prevBinaryFileTypeId = binaryFile != null ? binaryFile.BinaryFileTypeId : (int?)null;
}
// if a new file was uploaded, copy the uploaded file to this binaryFile (uploaded files are always new temporary binaryFiles)
if ( fsFile.BinaryFileId != binaryFile.Id)
{
var uploadedBinaryFile = binaryFileService.Get(fsFile.BinaryFileId ?? 0);
if (uploadedBinaryFile != null)
{
binaryFile.BinaryFileTypeId = uploadedBinaryFile.BinaryFileTypeId;
binaryFile.ContentStream = uploadedBinaryFile.ContentStream;
}
}
binaryFile.IsTemporary = false;
binaryFile.FileName = tbName.Text;
binaryFile.Description = tbDescription.Text;
binaryFile.MimeType = tbMimeType.Text;
binaryFile.BinaryFileTypeId = ddlBinaryFileType.SelectedValueAsInt();
binaryFile.LoadAttributes( rockContext );
Rock.Attribute.Helper.GetEditValues( phAttributes, binaryFile );
if ( !Page.IsValid )
{
return;
}
if ( !binaryFile.IsValid )
{
// Controls will render the error messages
return;
}
rockContext.WrapTransaction( () =>
{
foreach ( var id in OrphanedBinaryFileIdList )
{
var tempBinaryFile = binaryFileService.Get( id );
if ( tempBinaryFile != null && tempBinaryFile.IsTemporary )
{
binaryFileService.Delete( tempBinaryFile );
}
}
rockContext.SaveChanges();
binaryFile.SaveAttributeValues( rockContext );
} );
Rock.CheckIn.KioskLabel.Flush( binaryFile.Guid );
if ( !prevBinaryFileTypeId.Equals( binaryFile.BinaryFileTypeId ) )
{
var checkInBinaryFileType = new BinaryFileTypeService( rockContext )
.Get( Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL.AsGuid() );
if ( checkInBinaryFileType != null && (
( prevBinaryFileTypeId.HasValue && prevBinaryFileTypeId.Value == checkInBinaryFileType.Id ) ||
( binaryFile.BinaryFileTypeId.HasValue && binaryFile.BinaryFileTypeId.Value == checkInBinaryFileType.Id ) ) )
{
Rock.CheckIn.KioskDevice.FlushAll();
}
}
NavigateToParentPage();
}
/// <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 txnService = new FinancialTransactionService( rockContext );
var txnDetailService = new FinancialTransactionDetailService( rockContext );
var txnImageService = new FinancialTransactionImageService( rockContext );
var binaryFileService = new BinaryFileService( rockContext );
FinancialTransaction txn = null;
int? txnId = hfTransactionId.Value.AsIntegerOrNull();
int? batchId = hfBatchId.Value.AsIntegerOrNull();
if ( txnId.HasValue )
{
txn = txnService.Get( txnId.Value );
}
if ( txn == null && batchId.HasValue )
{
txn = new FinancialTransaction();
txnService.Add( txn );
txn.BatchId = batchId.Value;
}
if ( txn != null )
{
txn.AuthorizedPersonId = ppAuthorizedPerson.PersonId;
txn.TransactionDateTime = dtTransactionDateTime.SelectedDateTime;
txn.TransactionTypeValueId = ddlTransactionType.SelectedValue.AsInteger();
txn.SourceTypeValueId = ddlSourceType.SelectedValueAsInt();
Guid? gatewayGuid = cpPaymentGateway.SelectedValueAsGuid();
if ( gatewayGuid.HasValue )
{
var gatewayEntity = EntityTypeCache.Read( gatewayGuid.Value );
if ( gatewayEntity != null )
{
txn.GatewayEntityTypeId = gatewayEntity.Id;
}
else
{
txn.GatewayEntityTypeId = null;
}
}
else
{
txn.GatewayEntityTypeId = null;
}
txn.TransactionCode = tbTransactionCode.Text;
txn.CurrencyTypeValueId = ddlCurrencyType.SelectedValueAsInt();
txn.CreditCardTypeValueId = ddlCreditCardType.SelectedValueAsInt();
txn.Summary = tbSummary.Text;
if ( !Page.IsValid || !txn.IsValid )
{
return;
}
foreach ( var txnDetail in TransactionDetailsState )
{
if ( !txnDetail.IsValid )
{
return;
}
}
foreach ( var txnImage in TransactionImagesState )
{
if ( !txnImage.IsValid )
{
return;
}
}
rockContext.WrapTransaction( () =>
{
// Save the transaction
rockContext.SaveChanges();
// Delete any transaction details that were removed
var txnDetailsInDB = txnDetailService.Queryable().Where( a => a.TransactionId.Equals( txn.Id ) ).ToList();
var deletedDetails = from txnDetail in txnDetailsInDB
where !TransactionDetailsState.Select( d => d.Guid ).Contains( txnDetail.Guid )
select txnDetail;
deletedDetails.ToList().ForEach( txnDetail =>
{
txnDetailService.Delete( txnDetail );
} );
rockContext.SaveChanges();
// Save Transaction Details
foreach ( var editorTxnDetail in TransactionDetailsState )
{
// Add or Update the activity type
var txnDetail = txn.TransactionDetails.FirstOrDefault( d => d.Guid.Equals( editorTxnDetail.Guid ) );
if ( txnDetail == null )
{
txnDetail = new FinancialTransactionDetail();
txnDetail.Guid = editorTxnDetail.Guid;
txn.TransactionDetails.Add( txnDetail );
}
txnDetail.AccountId = editorTxnDetail.AccountId;
txnDetail.Amount = editorTxnDetail.Amount;
txnDetail.Summary = editorTxnDetail.Summary;
}
rockContext.SaveChanges();
// Remove any images that do not have a binary file
foreach ( var txnImage in TransactionImagesState.Where( i => i.BinaryFileId == 0 ).ToList() )
{
TransactionImagesState.Remove( txnImage );
}
// Delete any transaction images that were removed
var txnImagesInDB = txnImageService.Queryable().Where( a => a.TransactionId.Equals( txn.Id ) ).ToList();
var deletedImages = from txnImage in txnImagesInDB
where !TransactionImagesState.Select( d => d.Guid ).Contains( txnImage.Guid )
select txnImage;
deletedImages.ToList().ForEach( txnImage =>
{
txnImageService.Delete( txnImage );
} );
rockContext.SaveChanges();
// Save Transaction Images
foreach ( var editorTxnImage in TransactionImagesState )
{
// Add or Update the activity type
var txnImage = txn.Images.FirstOrDefault( d => d.Guid.Equals( editorTxnImage.Guid ) );
if ( txnImage == null )
{
txnImage = new FinancialTransactionImage();
txnImage.Guid = editorTxnImage.Guid;
txn.Images.Add( txnImage );
}
txnImage.BinaryFileId = editorTxnImage.BinaryFileId;
txnImage.TransactionImageTypeValueId = editorTxnImage.TransactionImageTypeValueId;
}
rockContext.SaveChanges();
// Make sure updated binary files are not temporary
var savedBinaryFileIds = txn.Images.Select( i => i.BinaryFileId ).ToList();
foreach ( var binaryFile in binaryFileService.Queryable().Where( f => savedBinaryFileIds.Contains( f.Id ) ) )
{
binaryFile.IsTemporary = false;
}
// Delete any orphaned images
var orphanedBinaryFileIds = BinaryFileIds.Where( f => !savedBinaryFileIds.Contains( f ) );
foreach ( var binaryFile in binaryFileService.Queryable().Where( f => orphanedBinaryFileIds.Contains( f.Id ) ) )
{
binaryFileService.Delete( binaryFile );
}
rockContext.SaveChanges();
} );
// Requery the batch to support EF navigation properties
var savedTxn = GetTransaction( txn.Id );
ShowReadOnlyDetails( savedTxn );
}
}
/// <summary>
/// Handles the Delete event to delete the photo.
/// </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 rGrid_Delete( object sender, RowEventArgs e )
{
RockContext rockContext = new RockContext();
int currentRowsPersonId = (int)e.RowKeyValues["PersonId"];
GroupService groupService = new GroupService( rockContext );
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
// Set their group member record to Active
Group group = groupService.Get( Rock.SystemGuid.Group.GROUP_PHOTO_REQUEST.AsGuid() );
GroupMember groupMember = group.Members.Where( m => m.PersonId == currentRowsPersonId ).FirstOrDefault();
if ( groupMember != null )
{
binaryFileService.Delete( groupMember.Person.Photo );
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
groupMember.Person.Photo = null;
groupMember.Person.PhotoId = null;
rockContext.SaveChanges();
_photoRequestGroup = group;
BindGrid();
}
}
/// <summary>
/// Handles the Click event of the lbMerge 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 lbMerge_Click( object sender, EventArgs e )
{
if ( MergeData.People.Count < 2 )
{
nbPeople.Visible = true;
return;
}
bool reconfirmRequired = ( MergeData.People.Select( p => p.Email ).Distinct().Count() > 1 && MergeData.People.Where( p => p.HasLogins ).Any() );
GetValuesSelection();
int? primaryPersonId = null;
var oldPhotos = new List<int>();
var rockContext = new RockContext();
rockContext.WrapTransaction( () =>
{
var personService = new PersonService( rockContext );
var userLoginService = new UserLoginService( rockContext );
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var binaryFileService = new BinaryFileService( rockContext );
var phoneNumberService = new PhoneNumberService( rockContext );
var taggedItemService = new TaggedItemService( rockContext );
Person primaryPerson = personService.Get( MergeData.PrimaryPersonId ?? 0 );
if ( primaryPerson != null )
{
primaryPersonId = primaryPerson.Id;
var changes = new List<string>();
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPerson.Id ) )
{
changes.Add( string.Format( "Merged <span class='field-value'>{0} [ID: {1}]</span> with this record.", p.FullName, p.Id ) );
}
// Photo Id
int? newPhotoId = MergeData.GetSelectedValue( MergeData.GetProperty( "Photo" ) ).Value.AsIntegerOrNull();
if ( !primaryPerson.PhotoId.Equals( newPhotoId ) )
{
changes.Add( "Modified the photo." );
primaryPerson.PhotoId = newPhotoId;
}
primaryPerson.TitleValueId = GetNewIntValue( "Title", changes );
primaryPerson.FirstName = GetNewStringValue( "FirstName", changes );
primaryPerson.NickName = GetNewStringValue( "NickName", changes );
primaryPerson.MiddleName = GetNewStringValue( "MiddleName", changes );
primaryPerson.LastName = GetNewStringValue( "LastName", changes );
primaryPerson.SuffixValueId = GetNewIntValue( "Suffix", changes );
primaryPerson.RecordTypeValueId = GetNewIntValue( "RecordType", changes );
primaryPerson.RecordStatusValueId = GetNewIntValue( "RecordStatus", changes );
primaryPerson.RecordStatusReasonValueId = GetNewIntValue( "RecordStatusReason", changes );
primaryPerson.ConnectionStatusValueId = GetNewIntValue( "ConnectionStatus", changes );
primaryPerson.IsDeceased = GetNewBoolValue( "Deceased", changes ) ?? false;
primaryPerson.Gender = (Gender)GetNewEnumValue( "Gender", typeof( Gender ), changes );
primaryPerson.MaritalStatusValueId = GetNewIntValue( "MaritalStatus", changes );
primaryPerson.SetBirthDate( GetNewDateTimeValue( "BirthDate", changes ) );
primaryPerson.AnniversaryDate = GetNewDateTimeValue( "AnniversaryDate", changes );
primaryPerson.GraduationYear = GetNewIntValue( "GraduationYear", changes );
primaryPerson.Email = GetNewStringValue( "Email", changes );
primaryPerson.IsEmailActive = GetNewBoolValue( "EmailActive", changes ) ?? true;
primaryPerson.EmailNote = GetNewStringValue( "EmailNote", changes );
primaryPerson.EmailPreference = (EmailPreference)GetNewEnumValue( "EmailPreference", typeof( EmailPreference ), changes );
primaryPerson.SystemNote = GetNewStringValue( "InactiveReasonNote", changes );
primaryPerson.SystemNote = GetNewStringValue( "SystemNote", changes );
// Update phone numbers
var phoneTypes = DefinedTypeCache.Read( Rock.SystemGuid.DefinedType.PERSON_PHONE_TYPE.AsGuid() ).DefinedValues;
foreach ( var phoneType in phoneTypes )
{
var phoneNumber = primaryPerson.PhoneNumbers.Where( p => p.NumberTypeValueId == phoneType.Id ).FirstOrDefault();
string oldValue = phoneNumber != null ? phoneNumber.Number : string.Empty;
string key = "phone_" + phoneType.Id.ToString();
string newValue = GetNewStringValue( key, changes );
bool phoneNumberDeleted = false;
if ( !oldValue.Equals( newValue, StringComparison.OrdinalIgnoreCase ) )
{
// New phone doesn't match old
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
// New value exists
if ( phoneNumber == null )
{
// Old value didn't exist... create new phone record
phoneNumber = new PhoneNumber { NumberTypeValueId = phoneType.Id };
primaryPerson.PhoneNumbers.Add( phoneNumber );
}
// Update phone number
phoneNumber.Number = newValue;
}
else
{
// New value doesn't exist
if ( phoneNumber != null )
{
// old value existed.. delete it
primaryPerson.PhoneNumbers.Remove( phoneNumber );
phoneNumberService.Delete( phoneNumber );
phoneNumberDeleted = true;
}
}
}
// check to see if IsMessagingEnabled is true for any of the merged people for this number/numbertype
if ( phoneNumber != null && !phoneNumberDeleted && !phoneNumber.IsMessagingEnabled )
{
var personIds = MergeData.People.Select( a => a.Id ).ToList();
var isMessagingEnabled = phoneNumberService.Queryable().Where( a => personIds.Contains( a.PersonId ) && a.Number == phoneNumber.Number && a.NumberTypeValueId == phoneNumber.NumberTypeValueId ).Any( a => a.IsMessagingEnabled );
if ( isMessagingEnabled )
{
phoneNumber.IsMessagingEnabled = true;
}
}
}
// Save the new record
rockContext.SaveChanges();
// Update the attributes
primaryPerson.LoadAttributes( rockContext );
foreach ( var property in MergeData.Properties.Where( p => p.Key.StartsWith( "attr_" ) ) )
{
string attributeKey = property.Key.Substring( 5 );
string oldValue = primaryPerson.GetAttributeValue( attributeKey ) ?? string.Empty;
string newValue = GetNewStringValue( property.Key, changes ) ?? string.Empty;
if ( !oldValue.Equals( newValue ) )
{
var attribute = primaryPerson.Attributes[attributeKey];
Rock.Attribute.Helper.SaveAttributeValue( primaryPerson, attribute, newValue, rockContext );
}
}
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
primaryPerson.Id, changes );
// Delete the unselected photos
string photoKeeper = primaryPerson.PhotoId.HasValue ? primaryPerson.PhotoId.Value.ToString() : string.Empty;
foreach ( var photoValue in MergeData.Properties
.Where( p => p.Key == "Photo" )
.SelectMany( p => p.Values )
.Where( v => v.Value != "" && v.Value != photoKeeper )
.Select( v => v.Value ) )
{
int photoId = 0;
if ( int.TryParse( photoValue, out photoId ) )
{
var photo = binaryFileService.Get( photoId );
if ( photo != null )
{
string errorMessages;
if ( binaryFileService.CanDelete( photo, out errorMessages ) )
{
binaryFileService.Delete( photo );
}
}
}
}
rockContext.SaveChanges();
// Delete merged person's family records and any families that would be empty after merge
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPersonId.Value ) )
{
// Delete the merged person's phone numbers (we've already updated the primary persons values)
foreach ( var phoneNumber in phoneNumberService.GetByPersonId( p.Id ) )
{
phoneNumberService.Delete( phoneNumber );
}
// If there was more than one email address and user has logins, then set any of the local
// logins ( database & AD ) to require a reconfirmation
if ( reconfirmRequired )
{
foreach ( var login in userLoginService.GetByPersonId( p.Id ) )
{
var component = Rock.Security.AuthenticationContainer.GetComponent( login.EntityType.Name );
if ( component != null && !component.RequiresRemoteAuthentication )
{
login.IsConfirmed = false;
}
}
}
rockContext.SaveChanges();
// Delete the merged person's other family member records and the family if they were the only one in the family
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
foreach ( var familyMember in groupMemberService.Queryable().Where( m => m.PersonId == p.Id && m.Group.GroupType.Guid == familyGuid ) )
{
groupMemberService.Delete( familyMember );
rockContext.SaveChanges();
// Get the family
var family = groupService.Queryable( "Members" ).Where( f => f.Id == familyMember.GroupId ).FirstOrDefault();
if ( !family.Members.Any() )
{
// If there are not any other family members, delete the family record.
// If theres any people that have this group as a giving group, set it to null (the person being merged should be the only one)
foreach ( Person gp in personService.Queryable().Where( g => g.GivingGroupId == family.Id ) )
{
gp.GivingGroupId = null;
}
// save to the database prior to doing groupService.Delete since .Delete quietly might not delete if thinks the Family is used for a GivingGroupId
rockContext.SaveChanges();
// Delete the family
string errorMessage;
if ( groupService.CanDelete( family, out errorMessage ) )
{
var oldFamilyChanges = new List<string>();
History.EvaluateChange( oldFamilyChanges, "Family", family.Name, string.Empty );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
primaryPersonId.Value, oldFamilyChanges, family.Name, typeof( Group ), family.Id );
groupService.Delete( family );
rockContext.SaveChanges();
}
}
}
}
// Flush any security roles that the merged person's other records were a part of
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPersonId.Value ) )
{
foreach ( var groupMember in groupMemberService.Queryable().Where( m => m.PersonId == p.Id ) )
{
Group group = new GroupService( rockContext ).Get( groupMember.GroupId );
if ( group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) )
{
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
}
// now that the Merge is complete, the EntitySet can be marked to be deleted by the RockCleanup job
var entitySetService = new EntitySetService( rockContext );
var entitySet = entitySetService.Get( MergeData.EntitySetId );
if ( entitySet != null )
{
entitySet.ExpireDateTime = RockDateTime.Now.AddMinutes(-1);
entitySet.EntitySetPurposeValueId = null;
rockContext.SaveChanges();
}
}
} );
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPersonId.Value ) )
{
// Run merge proc to merge all associated data
var parms = new Dictionary<string, object>();
parms.Add( "OldId", p.Id );
parms.Add( "NewId", primaryPersonId.Value );
DbService.ExecuteCommand( "spCrm_PersonMerge", CommandType.StoredProcedure, parms );
}
NavigateToLinkedPage( "PersonDetailPage", "PersonId", primaryPersonId.Value );
}
/// <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 )
{
var rockContext = new RockContext();
rockContext.WrapTransaction( () =>
{
var personService = new PersonService( rockContext );
var changes = new List<string>();
var person = personService.Get( CurrentPersonId ?? 0 );
if ( person != null )
{
int? orphanedPhotoId = null;
if ( person.PhotoId != imgPhoto.BinaryFileId )
{
orphanedPhotoId = person.PhotoId;
person.PhotoId = imgPhoto.BinaryFileId;
if ( orphanedPhotoId.HasValue )
{
if ( person.PhotoId.HasValue )
{
changes.Add( "Modified the photo." );
}
else
{
changes.Add( "Deleted the photo." );
}
}
else if ( person.PhotoId.HasValue )
{
changes.Add( "Added a photo." );
}
}
int? newTitleId = ddlTitle.SelectedValueAsInt();
History.EvaluateChange( changes, "Title", DefinedValueCache.GetName( person.TitleValueId ), DefinedValueCache.GetName( newTitleId ) );
person.TitleValueId = newTitleId;
History.EvaluateChange( changes, "First Name", person.FirstName, tbFirstName.Text );
person.FirstName = tbFirstName.Text;
History.EvaluateChange(changes, "Nick Name", person.NickName, tbNickName.Text);
person.NickName = tbNickName.Text;
History.EvaluateChange( changes, "Last Name", person.LastName, tbLastName.Text );
person.LastName = tbLastName.Text;
int? newSuffixId = ddlSuffix.SelectedValueAsInt();
History.EvaluateChange( changes, "Suffix", DefinedValueCache.GetName( person.SuffixValueId ), DefinedValueCache.GetName( newSuffixId ) );
person.SuffixValueId = newSuffixId;
var birthMonth = person.BirthMonth;
var birthDay = person.BirthDay;
var birthYear = person.BirthYear;
var birthday = bpBirthDay.SelectedDate;
if ( birthday.HasValue )
{
// If setting a future birthdate, subtract a century until birthdate is not greater than today.
var today = RockDateTime.Today;
while ( birthday.Value.CompareTo( today ) > 0 )
{
birthday = birthday.Value.AddYears( -100 );
}
person.BirthMonth = birthday.Value.Month;
person.BirthDay = birthday.Value.Day;
if ( birthday.Value.Year != DateTime.MinValue.Year )
{
person.BirthYear = birthday.Value.Year;
}
else
{
person.BirthYear = null;
}
}
else
{
person.SetBirthDate( null );
}
History.EvaluateChange( changes, "Birth Month", birthMonth, person.BirthMonth );
History.EvaluateChange( changes, "Birth Day", birthDay, person.BirthDay );
History.EvaluateChange( changes, "Birth Year", birthYear, person.BirthYear );
var newGender = rblGender.SelectedValue.ConvertToEnum<Gender>();
History.EvaluateChange( changes, "Gender", person.Gender, newGender );
person.Gender = newGender;
var phoneNumberTypeIds = new List<int>();
bool smsSelected = false;
foreach ( RepeaterItem item in rContactInfo.Items )
{
HiddenField hfPhoneType = item.FindControl( "hfPhoneType" ) as HiddenField;
PhoneNumberBox pnbPhone = item.FindControl( "pnbPhone" ) as PhoneNumberBox;
CheckBox cbUnlisted = item.FindControl( "cbUnlisted" ) as CheckBox;
CheckBox cbSms = item.FindControl( "cbSms" ) as CheckBox;
if ( hfPhoneType != null &&
pnbPhone != null &&
cbSms != null &&
cbUnlisted != null )
{
if ( !string.IsNullOrWhiteSpace( PhoneNumber.CleanNumber( pnbPhone.Number ) ) )
{
int phoneNumberTypeId;
if ( int.TryParse( hfPhoneType.Value, out phoneNumberTypeId ) )
{
var phoneNumber = person.PhoneNumbers.FirstOrDefault( n => n.NumberTypeValueId == phoneNumberTypeId );
string oldPhoneNumber = string.Empty;
if ( phoneNumber == null )
{
phoneNumber = new PhoneNumber { NumberTypeValueId = phoneNumberTypeId };
person.PhoneNumbers.Add( phoneNumber );
}
else
{
oldPhoneNumber = phoneNumber.NumberFormattedWithCountryCode;
}
phoneNumber.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode );
phoneNumber.Number = PhoneNumber.CleanNumber( pnbPhone.Number );
// Only allow one number to have SMS selected
if ( smsSelected )
{
phoneNumber.IsMessagingEnabled = false;
}
else
{
phoneNumber.IsMessagingEnabled = cbSms.Checked;
smsSelected = cbSms.Checked;
}
phoneNumber.IsUnlisted = cbUnlisted.Checked;
phoneNumberTypeIds.Add( phoneNumberTypeId );
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumberTypeId ) ),
oldPhoneNumber,
phoneNumber.NumberFormattedWithCountryCode );
}
}
}
}
// Remove any blank numbers
var phoneNumberService = new PhoneNumberService( rockContext );
foreach ( var phoneNumber in person.PhoneNumbers
.Where( n => n.NumberTypeValueId.HasValue && !phoneNumberTypeIds.Contains( n.NumberTypeValueId.Value ) )
.ToList() )
{
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumber.NumberTypeValueId ) ),
phoneNumber.ToString(),
string.Empty );
person.PhoneNumbers.Remove( phoneNumber );
phoneNumberService.Delete( phoneNumber );
}
History.EvaluateChange( changes, "Email", person.Email, tbEmail.Text );
person.Email = tbEmail.Text.Trim();
var newEmailPreference = rblEmailPreference.SelectedValue.ConvertToEnum<EmailPreference>();
History.EvaluateChange( changes, "Email Preference", person.EmailPreference, newEmailPreference );
person.EmailPreference = newEmailPreference;
if ( person.IsValid )
{
if ( rockContext.SaveChanges() > 0 )
{
if ( changes.Any() )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id,
changes );
}
if ( orphanedPhotoId.HasValue )
{
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( orphanedPhotoId.Value );
if ( binaryFile != null )
{
// marked the old images as IsTemporary so they will get cleaned up later
binaryFile.IsTemporary = true;
rockContext.SaveChanges();
}
}
// if they used the ImageEditor, and cropped it, the uncropped file is still in BinaryFile. So clean it up
if ( imgPhoto.CropBinaryFileId.HasValue )
{
if ( imgPhoto.CropBinaryFileId != person.PhotoId )
{
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( imgPhoto.CropBinaryFileId.Value );
if ( binaryFile != null && binaryFile.IsTemporary )
{
string errorMessage;
if ( binaryFileService.CanDelete( binaryFile, out errorMessage ) )
{
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
}
}
}
}
}
// save address
if ( pnlAddress.Visible )
{
Guid? familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuidOrNull();
if ( familyGroupTypeGuid.HasValue )
{
var familyGroup = new GroupService( rockContext ).Queryable()
.Where( f => f.GroupType.Guid == familyGroupTypeGuid.Value
&& f.Members.Any( m => m.PersonId == person.Id ) )
.FirstOrDefault();
if ( familyGroup != null )
{
Guid? addressTypeGuid = GetAttributeValue("LocationType").AsGuidOrNull();
if ( addressTypeGuid.HasValue )
{
var groupLocationService = new GroupLocationService( rockContext );
var dvHomeAddressType = DefinedValueCache.Read( addressTypeGuid.Value );
var familyAddress = groupLocationService.Queryable().Where( l => l.GroupId == familyGroup.Id && l.GroupLocationTypeValueId == dvHomeAddressType.Id ).FirstOrDefault();
if ( familyAddress != null && string.IsNullOrWhiteSpace( acAddress.Street1 ) )
{
// delete the current address
History.EvaluateChange( changes, familyAddress.GroupLocationTypeValue.Value + " Location", familyAddress.Location.ToString(), string.Empty );
groupLocationService.Delete( familyAddress );
rockContext.SaveChanges();
}
else
{
if ( !string.IsNullOrWhiteSpace( acAddress.Street1 ) )
{
if ( familyAddress == null )
{
familyAddress = new GroupLocation();
groupLocationService.Add( familyAddress );
familyAddress.GroupLocationTypeValueId = dvHomeAddressType.Id;
familyAddress.GroupId = familyGroup.Id;
familyAddress.IsMailingLocation = true;
familyAddress.IsMappedLocation = true;
}
else if ( hfStreet1.Value != string.Empty ) {
// user clicked move so create a previous address
var previousAddress = new GroupLocation();
groupLocationService.Add( previousAddress );
var previousAddressValue = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_PREVIOUS.AsGuid() );
if ( previousAddressValue != null )
{
previousAddress.GroupLocationTypeValueId = previousAddressValue.Id;
previousAddress.GroupId = familyGroup.Id;
Location previousAddressLocation = new Location();
previousAddressLocation.Street1 = hfStreet1.Value;
previousAddressLocation.Street2 = hfStreet2.Value;
previousAddressLocation.City = hfCity.Value;
previousAddressLocation.State = hfState.Value;
previousAddressLocation.PostalCode = hfPostalCode.Value;
previousAddressLocation.Country = hfCountry.Value;
previousAddress.Location = previousAddressLocation;
}
}
familyAddress.IsMailingLocation = cbIsMailingAddress.Checked;
familyAddress.IsMappedLocation = cbIsPhysicalAddress.Checked;
var updatedHomeAddress = new Location();
acAddress.GetValues( updatedHomeAddress );
History.EvaluateChange( changes, dvHomeAddressType.Value + " Location", familyAddress.Location != null ? familyAddress.Location.ToString() : string.Empty, updatedHomeAddress.ToString() );
familyAddress.Location = updatedHomeAddress;
rockContext.SaveChanges();
}
}
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id,
changes );
}
}
}
}
NavigateToParentPage();
}
}
} );
}
/// <summary>
/// Handles the Click event of the lbDelete 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 lbDelete_Click( object sender, EventArgs e )
{
LinkButton lbDelete = sender as LinkButton;
var imageId = int.Parse( lbDelete.Attributes["imageId"] );
var rockContext = new RockContext();
// Delete the reference to the binary file (image) from the FinancialTransactionImage table
var imageService = new FinancialTransactionImageService( rockContext );
var financialTransactionImage = imageService.Queryable().Where( image => image.BinaryFileId == imageId ).FirstOrDefault();
imageService.Delete( financialTransactionImage );
// Delete the actual binary file (image)
var binaryFileService = new BinaryFileService( rockContext );
var binaryFile = binaryFileService.Get( imageId );
binaryFileService.Delete( binaryFile );
rockContext.SaveChanges();
LoadRelatedImages( hfIdTransValue.ValueAsInt() );
}
