SaveChanges() public static method

Saves a list of history messages.
public static SaveChanges ( RockContext rockContext, Type modelType, System.Guid categoryGuid, int entityId, List changes, bool commitSave = true, int modifiedByPersonAliasId = null ) : void
rockContext Rock.Data.RockContext The rock context.
modelType System.Type Type of the model.
categoryGuid System.Guid The category unique identifier.
entityId int The entity identifier.
changes List The changes.
commitSave bool if set to true [commit save].
modifiedByPersonAliasId int The modified by person alias identifier.
return void
コード例 #1
0
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            var rockContext = dbContext as RockContext;

            if (GroupHistoryChanges != null && GroupHistoryChanges.Any())
            {
                HistoryService.SaveChanges(rockContext, typeof(Group), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(), GroupId, GroupHistoryChanges, true, this.ModifiedByPersonAliasId);
            }

            // If this is a Group of type Family, update the ModifiedDateTime on the Persons that are members of this family (since one of their Addresses changed)
            int groupTypeIdFamily = GroupTypeCache.GetFamilyGroupType().Id;
            var groupService      = new GroupService(rockContext);

            int groupTypeId = groupService.GetSelect(this.GroupId, s => s.GroupTypeId);

            if (groupTypeId == groupTypeIdFamily)
            {
                var currentDateTime    = RockDateTime.Now;
                var qryPersonsToUpdate = new GroupMemberService(rockContext).Queryable().Where(a => a.GroupId == this.GroupId).Select(a => a.Person);
                rockContext.BulkUpdate(qryPersonsToUpdate, p => new Person {
                    ModifiedDateTime = currentDateTime, ModifiedByPersonAliasId = this.ModifiedByPersonAliasId
                });
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #2
0
            /// <summary>
            /// Called after the save operation has been executed
            /// </summary>
            protected override void PostSave()
            {
                var rockContext = ( RockContext )this.RockContext;

                if (PersonHistoryChangeList?.Any() == true)
                {
                    var personAlias = Entity.PersonAlias ?? new PersonAliasService(rockContext).Get(Entity.PersonAliasId);
                    HistoryService.SaveChanges(
                        rockContext,
                        typeof(Person),
                        Rock.SystemGuid.Category.HISTORY_PERSON_STEP.AsGuid(),
                        personAlias.PersonId,
                        PersonHistoryChangeList,
                        Entity.Caption,
                        typeof(Step),
                        Entity.Id,
                        true,
                        Entity.ModifiedByPersonAliasId,
                        (rockContext.SourceOfChange));
                }

                base.PostSave();

                UpdateStepProgramCompletion(rockContext);
            }
コード例 #3
0
ファイル: GroupMember.cs プロジェクト: GenericChurch/Rock
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChanges != null)
            {
                foreach (var historyItem in HistoryChanges)
                {
                    int personId = historyItem.PersonId > 0 ? historyItem.PersonId : PersonId;

                    // if GroupId is 0, it is probably a Group that wasn't saved yet, so get the GroupId from historyItem.Group.Id instead
                    if (historyItem.GroupId == 0)
                    {
                        historyItem.GroupId = historyItem.Group?.Id;
                    }

                    HistoryService.SaveChanges(
                        ( RockContext )dbContext,
                        typeof(Person),
                        Rock.SystemGuid.Category.HISTORY_PERSON_GROUP_MEMBERSHIP.AsGuid(),
                        personId,
                        historyItem.PersonHistoryChangeList,
                        historyItem.Caption,
                        typeof(Group),
                        historyItem.GroupId,
                        true,
                        this.ModifiedByPersonAliasId,
                        dbContext.SourceOfChange);

                    HistoryService.SaveChanges(
                        ( RockContext )dbContext,
                        typeof(GroupMember),
                        Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(),
                        this.Id,
                        historyItem.GroupMemberHistoryChangeList,
                        historyItem.Caption,
                        typeof(Group),
                        historyItem.GroupId,
                        true,
                        this.ModifiedByPersonAliasId,
                        dbContext.SourceOfChange);
                }
            }

            base.PostSaveChanges(dbContext);

            // if this is a GroupMember record on a Family, ensure that AgeClassification, PrimaryFamily is updated
            // NOTE: This is also done on Person.PostSaveChanges in case Birthdate changes
            var groupTypeFamilyRoleIds = GroupTypeCache.GetFamilyGroupType()?.Roles?.Select(a => a.Id).ToList();

            if (groupTypeFamilyRoleIds?.Any() == true)
            {
                if (groupTypeFamilyRoleIds.Contains(this.GroupRoleId))
                {
                    PersonService.UpdatePersonAgeClassification(this.PersonId, dbContext as RockContext);
                    PersonService.UpdatePrimaryFamily(this.PersonId, dbContext as RockContext);
                    PersonService.UpdateGivingLeaderId(this.PersonId, dbContext as RockContext);
                }
            }
        }
コード例 #4
0
ファイル: PersonPreviousName.cs プロジェクト: ewin66/rockrms
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges( Data.DbContext dbContext )
        {
            if ( HistoryChanges != null && HistoryChanges.Any() && HistoryPersonId.HasValue )
            {
                HistoryService.SaveChanges( (RockContext)dbContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), HistoryPersonId.Value, HistoryChanges, true, this.ModifiedByPersonAliasId );
            }

            base.PostSaveChanges( dbContext );
        }
コード例 #5
0
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChangeList?.Any() == true)
            {
                HistoryService.SaveChanges(( RockContext )dbContext, typeof(FinancialScheduledTransaction), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), this.ScheduledTransactionId, HistoryChangeList, true, this.ModifiedByPersonAliasId);
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #6
0
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (GroupHistoryChanges != null && GroupHistoryChanges.Any())
            {
                HistoryService.SaveChanges((RockContext)dbContext, typeof(Group), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(), GroupId, GroupHistoryChanges, true, this.ModifiedByPersonAliasId);
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #7
0
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChangeList != null && HistoryChangeList.Any())
            {
                HistoryService.SaveChanges((RockContext)dbContext, typeof(Group), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(), this.Id, HistoryChangeList, this.Name, null, null, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #8
0
            /// <summary>
            /// Called after the save operation has been executed
            /// </summary>
            /// <remarks>
            /// This method is only called if <see cref="M:Rock.Data.EntitySaveHook`1.PreSave" /> returns
            /// without error.
            /// </remarks>
            protected override void PostSave()
            {
                var rockContext = ( RockContext )this.RockContext;

                if (HistoryChanges?.Any() == true && HistoryPersonId.HasValue)
                {
                    HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), HistoryPersonId.Value, HistoryChanges, true, Entity.ModifiedByPersonAliasId);
                }

                base.PostSave();
            }
コード例 #9
0
ファイル: PhoneNumber.cs プロジェクト: sjison/Rock
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (PersonHistoryChanges != null)
            {
                foreach (var keyVal in PersonHistoryChanges)
                {
                    int personId = keyVal.Key > 0 ? keyVal.Key : PersonId;
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), personId, keyVal.Value, true, this.ModifiedByPersonAliasId);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #10
0
ファイル: GroupMember.cs プロジェクト: sjison/Rock
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChanges != null)
            {
                foreach (var historyItem in HistoryChanges.Where(h => h.Changes.Any()))
                {
                    int personId = historyItem.PersonId > 0 ? historyItem.PersonId : PersonId;
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_GROUP_MEMBERSHIP.AsGuid(),
                                               personId, historyItem.Changes, historyItem.Caption, typeof(Group), historyItem.GroupId, true, this.ModifiedByPersonAliasId);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #11
0
            /// <summary>
            /// Method that will be called on an entity immediately after the item is saved by context
            /// </summary>
            /// <remarks>
            /// This method is only called if <see cref="M:Rock.Data.EntitySaveHook`1.PreSave" /> returns
            /// without error.
            /// </remarks>
            protected override void PostSave()
            {
                if (_declinedScheduledAttendance)
                {
                    new LaunchGroupScheduleCancellationWorkflow.Message()
                    {
                        AttendanceId = Entity.Id
                    }.Send();
                }

                if (!_isDeleted)
                {
                    // Process any streaks that may occur as a result of adding/modifying an attendance record.
                    // If there are any, they need to be processed in this thread in case there are any achievement changes
                    // that need to be detected as a result of this attendance.
                    StreakTypeService.HandleAttendanceRecord(Entity.Id);
                }

                var rockContext = ( RockContext )this.RockContext;

                if (PersonAttendanceHistoryChangeList?.Any() == true)
                {
                    var attendanceId = Entity.Id;

                    if (preSavePersonAliasId.HasValue)
                    {
                        var attendeePersonId = new PersonAliasService(this.RockContext).GetPersonId(preSavePersonAliasId.Value);
                        if (attendeePersonId.HasValue)
                        {
                            var entityTypeType        = typeof(Person);
                            var relatedEntityTypeType = typeof(Attendance);
                            HistoryService.SaveChanges(
                                rockContext,
                                entityTypeType,
                                Rock.SystemGuid.Category.HISTORY_ATTENDANCE_CHANGES.AsGuid(),
                                attendeePersonId.Value,
                                this.PersonAttendanceHistoryChangeList,
                                $"Attendance {attendanceId}",
                                relatedEntityTypeType,
                                attendanceId,
                                true,
                                Entity.ModifiedByPersonAliasId,
                                rockContext.SourceOfChange);
                        }
                    }
                }

                base.PostSave();
            }
コード例 #12
0
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            int?historyEntityId = (HistoryEntityId.HasValue && HistoryEntityId.Value > 0) ? HistoryEntityId.Value : this.EntityId;
            var rockContext     = dbContext as RockContext;

            if (HistoryChanges != null && HistoryChanges.Any() && HistoryEntityTypeId.HasValue && historyEntityId.HasValue)
            {
                if (HistoryEntityTypeId.Value == EntityTypeCache.Get(typeof(Person)).Id)
                {
                    HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), historyEntityId.Value, HistoryChanges, string.Empty, typeof(Attribute), AttributeId, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                }
                else
                {
                    HistoryService.SaveChanges(rockContext, typeof(Group), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(), historyEntityId.Value, HistoryChanges, string.Empty, typeof(Attribute), AttributeId, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                }
            }

            if (this.PostSaveAttributeValueHistoryCurrent)
            {
                var attributeValueHistoricalService            = new AttributeValueHistoricalService(rockContext);
                var attributeValueHistoricalPreviousCurrentRow = attributeValueHistoricalService.Queryable().Where(a => a.AttributeValueId == this.Id && a.CurrentRowIndicator == true).FirstOrDefault();
                var saveChangesDateTime = RockDateTime.Now;

                if (attributeValueHistoricalPreviousCurrentRow != null)
                {
                    attributeValueHistoricalPreviousCurrentRow.CurrentRowIndicator = false;
                    attributeValueHistoricalPreviousCurrentRow.ExpireDateTime      = saveChangesDateTime;
                }

                var attributeValueHistoricalCurrent = AttributeValueHistorical.CreateCurrentRowFromAttributeValue(this, saveChangesDateTime);

                attributeValueHistoricalService.Add(attributeValueHistoricalCurrent);
                rockContext.SaveChanges();
            }

            // If this a Person Attribute, Update the ModifiedDateTime on the Person that this AttributeValue is associated with
            if (this.EntityId.HasValue && AttributeCache.Get(this.AttributeId)?.EntityTypeId == EntityTypeCache.Get <Rock.Model.Person>().Id)
            {
                var currentDateTime    = RockDateTime.Now;
                int personId           = this.EntityId.Value;
                var qryPersonsToUpdate = new PersonService(rockContext).Queryable(true, true).Where(a => a.Id == personId);
                rockContext.BulkUpdate(qryPersonsToUpdate, p => new Person {
                    ModifiedDateTime = currentDateTime, ModifiedByPersonAliasId = this.ModifiedByPersonAliasId
                });
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #13
0
            /// <summary>
            /// Called after the save operation has been executed
            /// </summary>
            /// <remarks>
            /// This method is only called if <see cref="M:Rock.Data.EntitySaveHook`1.PreSave" /> returns
            /// without error.
            /// </remarks>
            protected override void PostSave()
            {
                var rockContext = ( RockContext )this.RockContext;

                if (HistoryChangeList?.Any() == true)
                {
                    HistoryService.SaveChanges(rockContext, typeof(Group), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(), Entity.Id, HistoryChangeList, Entity.Name, null, null, true, Entity.ModifiedByPersonAliasId, rockContext.SourceOfChange);
                }

                if (_FamilyCampusIsChanged)
                {
                    PersonService.UpdatePrimaryFamilyByGroup(Entity.Id, rockContext);
                }

                base.PostSave();
            }
コード例 #14
0
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChangeList.Any())
            {
                HistoryService.SaveChanges(( RockContext )dbContext, typeof(FinancialTransaction), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), this.TransactionId, HistoryChangeList, true, this.ModifiedByPersonAliasId);

                var txn = new FinancialTransactionService(( RockContext )dbContext).GetSelect(this.TransactionId, s => new { s.Id, s.BatchId });
                if (txn != null && txn.BatchId != null)
                {
                    var batchHistory = new History.HistoryChangeList();
                    batchHistory.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, $"Transaction ID:{txn.Id}");
                    HistoryService.SaveChanges(( RockContext )dbContext, typeof(FinancialBatch), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), txn.BatchId.Value, batchHistory, string.Empty, typeof(FinancialTransaction), this.TransactionId, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #15
0
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(DbContext dbContext)
        {
            if (HistoryChangeList.Any())
            {
                HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialTransaction), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), this.Id, HistoryChangeList, true, this.ModifiedByPersonAliasId);
            }

            foreach (var keyVal in BatchHistoryChangeList)
            {
                if (keyVal.Value.Any())
                {
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialBatch), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), keyVal.Key, keyVal.Value, string.Empty, typeof(FinancialTransaction), this.Id, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #16
0
ファイル: AttributeValue.cs プロジェクト: sjison/Rock
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            int?historyEntityId = (HistoryEntityId.HasValue && HistoryEntityId.Value > 0) ? HistoryEntityId.Value : this.EntityId;

            if (HistoryChanges != null && HistoryChanges.Any() && HistoryEntityTypeId.HasValue && historyEntityId.HasValue)
            {
                if (HistoryEntityTypeId.Value == EntityTypeCache.Read(typeof(Person)).Id)
                {
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), historyEntityId.Value, HistoryChanges, string.Empty, typeof(Attribute), AttributeId, true, this.ModifiedByPersonAliasId);
                }
                else
                {
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(Group), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(), historyEntityId.Value, HistoryChanges, string.Empty, typeof(Attribute), AttributeId, true, this.ModifiedByPersonAliasId);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #17
0
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(DbContext dbContext)
        {
            if (HistoryChanges.Any())
            {
                HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialTransaction), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), this.TransactionId, HistoryChanges, true, this.ModifiedByPersonAliasId);

                var txn = new FinancialTransactionService((RockContext)dbContext).Get(this.TransactionId);
                if (txn != null && txn.BatchId != null)
                {
                    var batchHistory = new List <string> {
                        string.Format("Updated <span class='field-name'>Transaction</span> ID: <span class='field-value'>{0}</span>.", txn.Id)
                    };
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialBatch), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), txn.BatchId.Value, batchHistory, string.Empty, typeof(FinancialTransaction), this.TransactionId, true, this.ModifiedByPersonAliasId);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #18
0
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved by context
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChangeList.Any())
            {
                foreach (var txn in new FinancialTransactionService((RockContext)dbContext)
                         .Queryable().AsNoTracking()
                         .Where(t => t.FinancialPaymentDetailId == this.Id)
                         .Select(t => new { t.Id, t.BatchId })
                         .ToList())
                {
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialTransaction), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), txn.Id, HistoryChangeList, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                    var batchHistory = new History.HistoryChangeList();
                    batchHistory.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Property, "Transaction");
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialBatch), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), txn.BatchId.Value, batchHistory, string.Empty, typeof(FinancialTransaction), txn.Id, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #19
0
            /// <summary>
            /// Called after the save operation has been executed
            /// </summary>
            /// <remarks>
            /// This method is only called if <see cref="M:Rock.Data.EntitySaveHook`1.PreSave" /> returns
            /// without error.
            /// </remarks>
            protected override void PostSave()
            {
                var personId = Entity.PersonId;

                if (personId.HasValue && State == EntityContextState.Added)
                {
                    // if EntityPerson doesn't lazy load, get it from the database using the same RockContext as this UserLogin record.
                    var userLoginPerson = Entity.Person ?? new PersonService(this.RockContext).Get(personId.Value);

                    // If this is a new userLogin for this person, ensure that the AccountProtection profile is at least Medium.
                    // Note that if this UserLogin is deleted, we'll let the RockCleanup job re-calculate their AccountProtectionProfile.
                    if (userLoginPerson != null && userLoginPerson.AccountProtectionProfile < Utility.Enums.AccountProtectionProfile.Medium)
                    {
                        // use a new RockContext to elevate the AccountProtection level to Medium
                        using (var rockContext = new RockContext())
                        {
                            var accountProtectionProfilePerson = new PersonService(rockContext).Get(personId.Value);

                            // double check that account protection profile needs to be elevated to medium
                            if (accountProtectionProfilePerson != null && accountProtectionProfilePerson.AccountProtectionProfile < Utility.Enums.AccountProtectionProfile.Medium)
                            {
                                accountProtectionProfilePerson.AccountProtectionProfile = Utility.Enums.AccountProtectionProfile.Medium;
                                rockContext.SaveChanges();
                            }
                        }
                    }
                }

                if (HistoryChanges?.Any() == true && Entity.PersonId.HasValue)
                {
                    try
                    {
                        HistoryService.SaveChanges(RockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), Entity.PersonId.Value, HistoryChanges, Entity.UserName, typeof(UserLogin), Entity.Id, true, Entity.ModifiedByPersonAliasId, null);
                    }
                    catch (Exception ex)
                    {
                        // Just log the problem and move on...
                        ExceptionLogService.LogException(ex);
                    }
                }

                base.PostSave();
            }
コード例 #20
0
ファイル: FinancialPaymentDetail.cs プロジェクト: sjison/Rock
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved by context
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChanges.Any())
            {
                foreach (var txn in new FinancialTransactionService((RockContext)dbContext)
                         .Queryable().AsNoTracking()
                         .Where(t => t.FinancialPaymentDetailId == this.Id)
                         .Select(t => new { t.Id, t.BatchId })
                         .ToList())
                {
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialTransaction), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), txn.Id, HistoryChanges, true, this.ModifiedByPersonAliasId);
                    var batchHistory = new List <string> {
                        string.Format("Updated <span class='field-name'>Transaction</span> ID: <span class='field-value'>{0}</span>.", txn.Id)
                    };
                    HistoryService.SaveChanges((RockContext)dbContext, typeof(FinancialBatch), Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(), txn.BatchId.Value, batchHistory, string.Empty, typeof(FinancialTransaction), txn.Id, true, this.ModifiedByPersonAliasId);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #21
0
        /// <summary>
        /// Method that will be called on an entity immediately after the item is saved.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            var rockContext = ( RockContext )dbContext;

            // It is possible that we have a UserLogin without a PersonId, in these cases we don't want to save a person history record.
            if (HistoryChanges != null && HistoryChanges.Any() && this.PersonId.HasValue)
            {
                try
                {
                    HistoryService.SaveChanges(( RockContext )dbContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), this.PersonId.Value, HistoryChanges, this.UserName, typeof(UserLogin), this.Id, true, this.ModifiedByPersonAliasId, null);
                }
                catch (Exception ex)
                {
                    // Just log the problem and move on...
                    ExceptionLogService.LogException(ex);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #22
0
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            var rockContext = dbContext as RockContext;

            if (PersonHistoryChanges != null)
            {
                foreach (var keyVal in PersonHistoryChanges)
                {
                    int personId = keyVal.Key > 0 ? keyVal.Key : PersonId;
                    HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), personId, keyVal.Value, true, this.ModifiedByPersonAliasId);
                }
            }

            // update the ModifiedDateTime on the Person that this phone number is associated with
            var currentDateTime    = RockDateTime.Now;
            var qryPersonsToUpdate = new PersonService(rockContext).Queryable(true, true).Where(a => a.Id == this.PersonId);

            rockContext.BulkUpdate(qryPersonsToUpdate, p => new Person {
                ModifiedDateTime = currentDateTime, ModifiedByPersonAliasId = this.ModifiedByPersonAliasId
            });

            base.PostSaveChanges(dbContext);
        }
コード例 #23
0
ファイル: GroupMember.cs プロジェクト: ewin66/rockrms
        /// <summary>
        /// Posts the save changes.
        /// </summary>
        /// <param name="dbContext">The database context.</param>
        public override void PostSaveChanges(Data.DbContext dbContext)
        {
            if (HistoryChanges != null)
            {
                foreach (var historyItem in HistoryChanges)
                {
                    int personId = historyItem.PersonId > 0 ? historyItem.PersonId : PersonId;

                    // if GroupId is 0, it is probably a Group that wasn't saved yet, so get the GroupId from historyItem.Group.Id instead
                    if (historyItem.GroupId == 0)
                    {
                        historyItem.GroupId = historyItem.Group?.Id;
                    }

                    HistoryService.SaveChanges((RockContext)dbContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_GROUP_MEMBERSHIP.AsGuid(),
                                               personId, historyItem.PersonHistoryChangeList, historyItem.Caption, typeof(Group), historyItem.GroupId, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);

                    HistoryService.SaveChanges(( RockContext )dbContext, typeof(GroupMember), Rock.SystemGuid.Category.HISTORY_GROUP_CHANGES.AsGuid(),
                                               this.Id, historyItem.GroupMemberHistoryChangeList, historyItem.Caption, typeof(Group), historyItem.GroupId, true, this.ModifiedByPersonAliasId, dbContext.SourceOfChange);
                }
            }

            base.PostSaveChanges(dbContext);
        }
コード例 #24
0
        /// <summary>
        /// Method that will be called on an entity immediately before the item is saved by context.  Takes
        /// care of logging any particular change history for user login.
        /// </summary>
        /// <param name="dbContext"></param>
        /// <param name="entry"></param>
        public override void PreSaveChanges(Rock.Data.DbContext dbContext, DbEntityEntry entry)
        {
            var rockContext = ( RockContext )dbContext;

            HistoryChanges = new History.HistoryChangeList();

            switch (entry.State)
            {
            case EntityState.Added:
            {
                // Get the authentication provider entity type
                var entityType = EntityTypeCache.Get(this.EntityTypeId ?? 0);
                var change     = HistoryChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, "Authentication Provider").SetNewValue(entityType?.FriendlyName);

                // Don't log Pin Authentication user names.
                var isUserNameSensitive = (entityType?.Guid == Rock.SystemGuid.EntityType.AUTHENTICATION_PIN.AsGuid()) ? true : false;

                if (isUserNameSensitive)
                {
                    change.SetCaption("User Account");
                }

                History.EvaluateChange(HistoryChanges, "User Login", string.Empty, UserName, isUserNameSensitive);
                History.EvaluateChange(HistoryChanges, "Is Confirmed", null, IsConfirmed);
                History.EvaluateChange(HistoryChanges, "Is Password Change Required", null, IsPasswordChangeRequired);
                History.EvaluateChange(HistoryChanges, "Is Locked Out", null, IsLockedOut);

                break;
            }

            case EntityState.Modified:
            {
                var entityType = EntityTypeCache.Get(this.EntityTypeId ?? 0);

                // Don't log Pin Authentication user names.
                var isUserNameSensitive = (entityType?.Guid == Rock.SystemGuid.EntityType.AUTHENTICATION_PIN.AsGuid()) ? true : false;

                History.EvaluateChange(HistoryChanges, "User Login", entry.OriginalValues["UserName"].ToStringSafe(), UserName, isUserNameSensitive);
                History.EvaluateChange(HistoryChanges, "Is Confirmed", entry.OriginalValues["IsConfirmed"].ToStringSafe().AsBooleanOrNull(), IsConfirmed);
                History.EvaluateChange(HistoryChanges, "Is Password Change Required", entry.OriginalValues["IsPasswordChangeRequired"].ToStringSafe().AsBooleanOrNull(), IsPasswordChangeRequired);
                History.EvaluateChange(HistoryChanges, "Is Locked Out", entry.OriginalValues["IsLockedOut"].ToStringSafe().AsBooleanOrNull(), IsLockedOut);
                History.EvaluateChange(HistoryChanges, "Password", entry.OriginalValues["Password"].ToStringSafe(), Password, true);

                // Did the provider type change?
                int?origEntityTypeId = entry.OriginalValues["EntityTypeId"].ToStringSafe().AsIntegerOrNull();
                int?entityTypeId     = EntityType != null ? EntityType.Id : EntityTypeId;
                if (!entityTypeId.Equals(origEntityTypeId))
                {
                    var origProviderType = EntityTypeCache.Get(origEntityTypeId ?? 0)?.FriendlyName;
                    var providerType     = EntityTypeCache.Get(this.EntityTypeId ?? 0)?.FriendlyName;
                    History.EvaluateChange(HistoryChanges, "User Login", origProviderType, providerType);
                }

                // Change the caption if this is a sensitive user account
                if (HistoryChanges.Count > 0 && isUserNameSensitive)
                {
                    var change = HistoryChanges.FirstOrDefault();
                    change.SetCaption("User Account");
                }

                break;
            }

            case EntityState.Deleted:
            {
                // By this point EF has stripped out some of the data we need to save history
                // Reload the data using a new context.
                RockContext newRockContext = new RockContext();
                var         userLogin      = new UserLoginService(newRockContext).Get(this.Id);
                if (userLogin != null && userLogin.PersonId != null)
                {
                    try
                    {
                        var entityType          = EntityTypeCache.Get(userLogin.EntityTypeId ?? 0);
                        var isUserNameSensitive = (entityType?.Guid == Rock.SystemGuid.EntityType.AUTHENTICATION_PIN.AsGuid()) ? true : false;

                        if (!isUserNameSensitive)
                        {
                            HistoryChanges.AddChange(History.HistoryVerb.Delete, History.HistoryChangeType.Record, "User Login").SetOldValue(userLogin.UserName);
                            HistoryService.SaveChanges(newRockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), userLogin.PersonId.Value, HistoryChanges, UserName, typeof(UserLogin), this.Id, true, userLogin.ModifiedByPersonAliasId, null);
                        }
                        else
                        {
                            HistoryChanges.AddChange(History.HistoryVerb.Delete, History.HistoryChangeType.Record, "Authentication Provider").SetOldValue(entityType?.FriendlyName).SetCaption("User Account");
                            HistoryService.SaveChanges(newRockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), userLogin.PersonId.Value, HistoryChanges, entityType?.FriendlyName, typeof(UserLogin), this.Id, true, userLogin.ModifiedByPersonAliasId, null);
                        }
                    }
                    catch (Exception ex)
                    {
                        // Just log the problem and move on...
                        ExceptionLogService.LogException(ex);
                    }
                }

                HistoryChanges.Clear();
                return;
            }
            }

            base.PreSaveChanges(dbContext, entry);
        }
コード例 #25
0
ファイル: AddFamily.ascx.cs プロジェクト: pkdevbox/Rock
        protected void btnNext_Click( object sender, EventArgs e )
        {
            if ( Page.IsValid )
            {
                if ( CurrentCategoryIndex < attributeControls.Count )
                {
                    CurrentCategoryIndex++;
                    ShowAttributeCategory( CurrentCategoryIndex );
                }
                else
                {
                    var familyMembers = GetControlData();
                    if ( familyMembers.Any() )
                    {

                        RockTransactionScope.WrapTransaction( () =>
                        {
                            using ( new UnitOfWorkScope() )
                            {
                                var familyGroupType = GroupTypeCache.GetFamilyGroupType();

                                var familyChanges = new List<string>();
                                var familyMemberChanges = new Dictionary<Guid, List<string>>();
                                var familyDemographicChanges = new Dictionary<Guid, List<string>>();

                                if ( familyGroupType != null )
                                {
                                    var groupService = new GroupService();

                                    var groupTypeRoleService = new GroupTypeRoleService();

                                    var familyGroup = new Group();
                                    familyGroup.GroupTypeId = familyGroupType.Id;
                                    
                                    familyChanges.Add("Created");
                                    
                                    familyGroup.Name = familyMembers.FirstOrDefault().Person.LastName + " Family";
                                    History.EvaluateChange( familyChanges, "Name", string.Empty, familyGroup.Name );

                                    int? campusId = cpCampus.SelectedValueAsInt();
                                    if (campusId.HasValue)
                                    {
                                        History.EvaluateChange( familyChanges, "Campus", string.Empty, CampusCache.Read( campusId.Value ).Name );
                                    }
                                    familyGroup.CampusId = campusId;

                                    foreach(var familyMember in familyMembers)
                                    {
                                        var person = familyMember.Person;
                                        if ( person != null )
                                        {
                                            familyGroup.Members.Add( familyMember );

                                            var demographicChanges = new List<string>();
                                            demographicChanges.Add( "Created" );
                                            History.EvaluateChange( demographicChanges, "Record Status", string.Empty,
                                                person.RecordStatusReasonValueId.HasValue ? DefinedValueCache.GetName( person.RecordStatusReasonValueId.Value ) : string.Empty );
                                            History.EvaluateChange( demographicChanges, "Title", string.Empty,
                                                person.TitleValueId.HasValue ? DefinedValueCache.GetName( person.TitleValueId ) : string.Empty );
                                            History.EvaluateChange( demographicChanges, "First Name", string.Empty, person.FirstName);
                                            History.EvaluateChange( demographicChanges, "Nick Name", string.Empty, person.NickName );
                                            History.EvaluateChange( demographicChanges, "Middle Name", string.Empty, person.MiddleName );
                                            History.EvaluateChange( demographicChanges, "Last Name", string.Empty, person.LastName );
                                            History.EvaluateChange( demographicChanges, "Gender", null, person.Gender );
                                            History.EvaluateChange( demographicChanges, "Birth Date", null, person.BirthDate );
                                            History.EvaluateChange( demographicChanges, "Connection Status", string.Empty,
                                                person.ConnectionStatusValueId.HasValue ? DefinedValueCache.GetName( person.ConnectionStatusValueId ) : string.Empty );
                                            History.EvaluateChange( demographicChanges, "Graduation Date", null, person.GraduationDate );
                                            familyDemographicChanges.Add( person.Guid, demographicChanges );

                                            var memberChanges = new List<string>();
                                            string roleName = familyGroupType.Roles[familyMember.GroupRoleId] ?? string.Empty;
                                            History.EvaluateChange( memberChanges, "Role", string.Empty, roleName );
                                            familyMemberChanges.Add( person.Guid, memberChanges );
                                        }
                                    }

                                    if ( !String.IsNullOrWhiteSpace( tbStreet1.Text ) ||
                                         !String.IsNullOrWhiteSpace( tbStreet2.Text ) ||
                                         !String.IsNullOrWhiteSpace( tbCity.Text ) ||
                                         !String.IsNullOrWhiteSpace( tbZip.Text ) )
                                    {
                                        string addressChangeField = "Address";

                                        var groupLocation = new GroupLocation();
                                        var location = new LocationService().Get(
                                            tbStreet1.Text, tbStreet2.Text, tbCity.Text, ddlState.SelectedValue, tbZip.Text );
                                        groupLocation.Location = location;

                                        Guid locationTypeGuid = Guid.Empty;
                                        if ( Guid.TryParse( GetAttributeValue( "LocationType" ), out locationTypeGuid ) )
                                        {
                                            var locationType = Rock.Web.Cache.DefinedValueCache.Read( locationTypeGuid );
                                            if ( locationType != null )
                                            {
                                                addressChangeField = string.Format("{0} Address", locationType.Name);
                                                groupLocation.GroupLocationTypeValueId = locationType.Id;
                                            }
                                        }

                                        familyGroup.GroupLocations.Add( groupLocation );

                                        History.EvaluateChange( familyChanges, addressChangeField, string.Empty, groupLocation.Location.ToString() );
                                    }


                                    groupService.Add( familyGroup, CurrentPersonId );
                                    groupService.Save( familyGroup, CurrentPersonId );

                                    var historyService = new HistoryService();
                                    historyService.SaveChanges( typeof( Group ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                        familyGroup.Id, familyChanges, CurrentPersonId );

                                    var personService = new PersonService();

                                    foreach ( var groupMember in familyMembers )
                                    {
                                        var person = personService.Get( groupMember.PersonId );
                                        if ( person != null )
                                        {
                                            var changes = familyDemographicChanges[person.Guid];
                                            if ( groupMember.GroupRoleId != _childRoleId )
                                            {
                                                person.GivingGroupId = familyGroup.Id;
                                                personService.Save( person, CurrentPersonId );
                                                History.EvaluateChange( changes, "Giving Group", string.Empty, familyGroup.Name );
                                            }

                                            foreach ( var attributeControl in attributeControls )
                                            {
                                                foreach ( var attribute in attributeControl.AttributeList )
                                                {
                                                    string attributeValue = person.GetAttributeValue( attribute.Key );
                                                    if ( !string.IsNullOrWhiteSpace( attributeValue ) )
                                                    {
                                                        Rock.Attribute.Helper.SaveAttributeValue( person, attribute, attributeValue, CurrentPersonId );
                                                        attributeValue = attribute.FieldType.Field.FormatValue( null, attributeValue, attribute.QualifierValues, false );
                                                        History.EvaluateChange( changes, attribute.Name, string.Empty, attributeValue );
                                                    }
                                                }
                                            }

                                            historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
                                                person.Id, changes, CurrentPersonId );

                                            historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                                person.Id, familyMemberChanges[person.Guid], familyGroup.Name, typeof( Group), familyGroup.Id, CurrentPersonId );
                                        }
                                    }
                                }
                            }
                        } );

                        Response.Redirect( string.Format( "~/Person/{0}", familyMembers[0].Person.Id ), false );
                    }

                }
            }

        }
コード例 #26
0
        /// <summary>
        /// Creates a new <see cref="Rock.Model.UserLogin" />
        /// </summary>
        /// <param name="rockContext">The rock context.</param>
        /// <param name="person">The <see cref="Rock.Model.Person" /> that this <see cref="UserLogin" /> will be associated with.</param>
        /// <param name="serviceType">The <see cref="Rock.Model.AuthenticationServiceType" /> type of Login</param>
        /// <param name="entityTypeId">The entity type identifier.</param>
        /// <param name="username">A <see cref="System.String" /> containing the UserName.</param>
        /// <param name="password">A <see cref="System.String" /> containing the unhashed/unencrypted password.</param>
        /// <param name="isConfirmed">A <see cref="System.Boolean" /> flag indicating if the user has been confirmed.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the Username already exists.</exception>
        /// <exception cref="System.ArgumentException">Thrown when the service does not exist or is not active.</exception>
        public static UserLogin Create(RockContext rockContext,
                                       Rock.Model.Person person,
                                       AuthenticationServiceType serviceType,
                                       int entityTypeId,
                                       string username,
                                       string password,
                                       bool isConfirmed)
        {
            if (person != null)
            {
                var userLoginService = new UserLoginService(rockContext);

                var entityType = EntityTypeCache.Read(entityTypeId);
                if (entityType != null)
                {
                    UserLogin user = userLoginService.GetByUserName(username);
                    if (user != null)
                    {
                        throw new ArgumentOutOfRangeException("username", "Username already exists");
                    }

                    DateTime createDate = RockDateTime.Now;

                    user              = new UserLogin();
                    user.Guid         = Guid.NewGuid();
                    user.EntityTypeId = entityTypeId;
                    user.UserName     = username;
                    user.IsConfirmed  = isConfirmed;
                    user.LastPasswordChangedDateTime = createDate;
                    user.PersonId = person.Id;

                    if (serviceType == AuthenticationServiceType.Internal)
                    {
                        var authenticationComponent = AuthenticationContainer.GetComponent(entityType.Name);
                        if (authenticationComponent == null || !authenticationComponent.IsActive)
                        {
                            throw new ArgumentException(string.Format("'{0}' service does not exist, or is not active", entityType.FriendlyName), "entityTypeId");
                        }

                        user.Password = authenticationComponent.EncodePassword(user, password);
                    }

                    userLoginService.Add(user);
                    rockContext.SaveChanges();

                    var historyCategory = CategoryCache.Read(Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), rockContext);
                    if (historyCategory != null)
                    {
                        var changes = new List <string>();
                        History.EvaluateChange(changes, "User Login", string.Empty, username);
                        HistoryService.SaveChanges(rockContext, typeof(Person), historyCategory.Guid, person.Id, changes);
                    }

                    return(user);
                }
                else
                {
                    throw new ArgumentException("Invalid EntityTypeId, entity does not exist", "entityTypeId");
                }
            }
            else
            {
                throw new ArgumentException("Invalid Person, person does not exist", "person");
            }
        }
コード例 #27
0
ファイル: EditFamily.ascx.cs プロジェクト: pkdevbox/Rock
        /// <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 )
        {
            // confirmation was disabled by btnSave on client-side.  So if returning without a redirect,
            // it should be enabled.  If returning with a redirect, the control won't be updated to reflect
            // confirmation being enabled, so it's ok to enable it here
            confirmExit.Enabled = true;

            if ( Page.IsValid )
            {
                confirmExit.Enabled = true;

                RockTransactionScope.WrapTransaction( () =>
                {

                    using ( new UnitOfWorkScope() )
                    {
                        var familyService = new GroupService();
                        var familyMemberService = new GroupMemberService();
                        var personService = new PersonService();
                        var historyService = new HistoryService();

                        var familyChanges = new List<string>();

                        // SAVE FAMILY
                        _family = familyService.Get( _family.Id );

                        History.EvaluateChange( familyChanges, "Name", _family.Name, tbFamilyName.Text );
                        _family.Name = tbFamilyName.Text;

                        int? campusId = cpCampus.SelectedValueAsInt();
                        if ( _family.CampusId != campusId )
                        {
                            History.EvaluateChange( familyChanges, "Campus",
                                _family.CampusId.HasValue ? CampusCache.Read( _family.CampusId.Value ).Name : string.Empty,
                                campusId.HasValue ? CampusCache.Read( campusId.Value ).Name : string.Empty );
                            _family.CampusId = campusId;
                        }

                        var familyGroupTypeId = _family.GroupTypeId;

                        familyService.Save( _family, CurrentPersonId );

                        // SAVE FAMILY MEMBERS
                        int? recordStatusValueID = ddlRecordStatus.SelectedValueAsInt();
                        int? reasonValueId = ddlReason.SelectedValueAsInt();
                        var newFamilies = new List<Group>();

                        foreach ( var familyMember in FamilyMembers )
                        {
                            var memberChanges = new List<string>();
                            var demographicChanges = new List<string>();

                            var role = familyRoles.Where( r => r.Guid.Equals( familyMember.RoleGuid ) ).FirstOrDefault();
                            if ( role == null )
                            {
                                role = familyRoles.FirstOrDefault();
                            }

                            bool isChild = role != null && role.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) );

                            // People added to family (new or from other family)
                            if ( !familyMember.ExistingFamilyMember )
                            {
                                var groupMember = new GroupMember();

                                if ( familyMember.Id == -1 )
                                {
                                    // added new person
                                    demographicChanges.Add( "Created" );

                                    var person = new Person();
                                    person.FirstName = familyMember.FirstName;
                                    History.EvaluateChange( demographicChanges, "First Name", string.Empty, person.FirstName );

                                    person.LastName = familyMember.LastName;
                                    History.EvaluateChange( demographicChanges, "Last Name", string.Empty, person.LastName );

                                    person.Gender = familyMember.Gender;
                                    History.EvaluateChange( demographicChanges, "Gender", null, person.Gender );

                                    person.BirthDate = familyMember.BirthDate;
                                    History.EvaluateChange( demographicChanges, "Birth Date", null, person.BirthDate );

                                    if ( !isChild )
                                    {
                                        person.GivingGroupId = _family.Id;
                                        History.EvaluateChange( demographicChanges, "Giving Group", string.Empty, _family.Name );
                                    }

                                    groupMember.Person = person;
                                }
                                else
                                {
                                    // added from other family
                                    groupMember.Person = personService.Get( familyMember.Id );
                                }

                                History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( groupMember.Person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
                                groupMember.Person.RecordStatusValueId = recordStatusValueID;

                                History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( groupMember.Person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
                                groupMember.Person.RecordStatusReasonValueId = reasonValueId;

                                groupMember.GroupId = _family.Id;
                                if ( role != null )
                                {
                                    History.EvaluateChange( memberChanges, string.Format( "Role", _family.Name ), string.Empty, role.Name );
                                    groupMember.GroupRoleId = role.Id;
                                }

                                if ( groupMember.Person != null )
                                {
                                    familyMemberService.Add( groupMember, CurrentPersonId );
                                    familyMemberService.Save( groupMember, CurrentPersonId );
                                }

                            }
                            else
                            {
                                // existing family members
                                var groupMember = familyMemberService.Queryable( "Person" ).Where( m =>
                                    m.PersonId == familyMember.Id &&
                                    m.Group.GroupTypeId == familyGroupTypeId &&
                                    m.GroupId == _family.Id ).FirstOrDefault();
                                if ( groupMember != null )
                                {

                                    if ( familyMember.Removed )
                                    {
                                        var newFamilyChanges = new List<string>();
                                        newFamilyChanges.Add( "Created" );

                                        // Family member was removed and should be created in their own new family
                                        var newFamily = new Group();
                                        newFamily.Name = familyMember.LastName + " Family";
                                        History.EvaluateChange( newFamilyChanges, "Name", string.Empty, newFamily.Name );

                                        newFamily.GroupTypeId = familyGroupTypeId;

                                        if ( _family.CampusId.HasValue )
                                        {
                                            History.EvaluateChange( newFamilyChanges, "Campus", string.Empty, CampusCache.Read( _family.CampusId.Value ).Name );
                                        }
                                        newFamily.CampusId = _family.CampusId;

                                        familyService.Add( newFamily, CurrentPersonId );
                                        familyService.Save( newFamily, CurrentPersonId );

                                        historyService.SaveChanges( typeof( Group ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                            newFamily.Id, newFamilyChanges, CurrentPersonId );

                                        // If person's previous giving group was this family, set it to their new family id
                                        if ( groupMember.Person.GivingGroup != null && groupMember.Person.GivingGroupId == _family.Id )
                                        {
                                            History.EvaluateChange( demographicChanges, "Giving Group", groupMember.Person.GivingGroup.Name, _family.Name );
                                            groupMember.Person.GivingGroupId = newFamily.Id;
                                        }

                                        groupMember.Group = newFamily;
                                        familyMemberService.Save( groupMember, CurrentPersonId );

                                        var newMemberChanges = new List<string>();
                                        History.EvaluateChange( newMemberChanges, "Role", string.Empty, groupMember.GroupRole.Name );
                                        historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                            groupMember.Person.Id, newMemberChanges, CurrentPersonId );

                                        History.EvaluateChange( memberChanges, "Role", groupMember.GroupRole.Name, string.Empty );

                                        newFamilies.Add( newFamily );
                                    }
                                    else
                                    {
                                        // Existing member was not remvoved
                                        if ( role != null )
                                        {
                                            History.EvaluateChange( memberChanges, "Role",
                                                groupMember.GroupRole != null ? groupMember.GroupRole.Name : string.Empty, role.Name );
                                            groupMember.GroupRoleId = role.Id;

                                            History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( groupMember.Person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
                                            groupMember.Person.RecordStatusValueId = recordStatusValueID;

                                            History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( groupMember.Person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
                                            groupMember.Person.RecordStatusReasonValueId = reasonValueId;

                                            familyMemberService.Save( groupMember, CurrentPersonId );
                                        }
                                    }
                                }
                            }

                            // Remove anyone that was moved from another family
                            if ( familyMember.RemoveFromOtherFamilies )
                            {
                                var otherFamilies = familyMemberService.Queryable()
                                    .Where( m =>
                                        m.PersonId == familyMember.Id &&
                                        m.Group.GroupTypeId == familyGroupTypeId &&
                                        m.GroupId != _family.Id )
                                    .ToList();

                                foreach ( var otherFamilyMember in otherFamilies )
                                {
                                    var fm = familyMemberService.Get( otherFamilyMember.Id );

                                    // If the person's giving group id was the family they are being removed from, update it to this new family's id
                                    if ( fm.Person.GivingGroupId == fm.GroupId )
                                    {
                                        var person = personService.Get( fm.PersonId );

                                        History.EvaluateChange( demographicChanges, "Giving Group", person.GivingGroup.Name, _family.Name );
                                        person.GivingGroupId = _family.Id;

                                        personService.Save( person, CurrentPersonId );
                                    }

                                    var oldMemberChanges = new List<string>();
                                    History.EvaluateChange( oldMemberChanges, "Role", fm.GroupRole.Name, string.Empty );

                                    familyMemberService.Delete( fm, CurrentPersonId );
                                    familyMemberService.Save( fm, CurrentPersonId );

                                    historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                        fm.Person.Id, oldMemberChanges, CurrentPersonId );

                                    var f = familyService.Queryable()
                                        .Where( g =>
                                            g.Id == otherFamilyMember.GroupId &&
                                            !g.Members.Any() )
                                        .FirstOrDefault();

                                    if ( f != null )
                                    {
                                        var oldFamilyChanges = new List<string>();
                                        oldFamilyChanges.Add( "Deleted" );
                                        historyService.SaveChanges( typeof( Group ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                            f.Id, oldFamilyChanges, CurrentPersonId );

                                        familyService.Delete( f, CurrentPersonId );
                                        familyService.Save( f, CurrentPersonId );
                                    }
                                }
                            }

                            historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
                                familyMember.Id, demographicChanges, CurrentPersonId );

                            historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                familyMember.Id, memberChanges, _family.Name, typeof( Group ), _family.Id, CurrentPersonId );
                        }

                        // SAVE LOCATIONS
                        var groupLocationService = new GroupLocationService();

                        // delete any group locations that were removed
                        var remainingLocationIds = FamilyAddresses.Where( a => a.Id > 0 ).Select( a => a.Id ).ToList();
                        foreach ( var removedLocation in groupLocationService.Queryable( "GroupLocationTypeValue,Location" )
                            .Where( l => l.GroupId == _family.Id &&
                                !remainingLocationIds.Contains( l.Id ) ) )
                        {
                            History.EvaluateChange( familyChanges, removedLocation.GroupLocationTypeValue.Name + " Location",
                                removedLocation.Location.ToString(), string.Empty );
                            groupLocationService.Delete( removedLocation, CurrentPersonId );
                            groupLocationService.Save( removedLocation, CurrentPersonId );
                        }

                        foreach ( var familyAddress in FamilyAddresses )
                        {
                            Location updatedAddress = null;
                            if ( familyAddress.LocationIsDirty )
                            {
                                updatedAddress = new LocationService().Get(
                                    familyAddress.Street1, familyAddress.Street2, familyAddress.City,
                                    familyAddress.State, familyAddress.Zip );
                            }

                            GroupLocation groupLocation = null;
                            if ( familyAddress.Id > 0 )
                            {
                                groupLocation = groupLocationService.Get( familyAddress.Id );
                            }
                            if ( groupLocation == null )
                            {
                                groupLocation = new GroupLocation();
                                groupLocation.GroupId = _family.Id;
                                groupLocationService.Add( groupLocation, CurrentPersonId );
                            }

                            History.EvaluateChange( familyChanges, "Location Type",
                                groupLocation.GroupLocationTypeValueId.HasValue ? DefinedValueCache.Read( groupLocation.GroupLocationTypeValueId.Value ).Name : string.Empty,
                                familyAddress.LocationTypeName );
                            groupLocation.GroupLocationTypeValueId = familyAddress.LocationTypeId;

                            History.EvaluateChange( familyChanges, familyAddress.LocationTypeName + " Location Is Mailing",
                                groupLocation.IsMailingLocation.ToString(), familyAddress.IsMailing.ToString() );
                            groupLocation.IsMailingLocation = familyAddress.IsMailing;

                            History.EvaluateChange( familyChanges, familyAddress.LocationTypeName + " Location Is Location",
                                groupLocation.IsMappedLocation.ToString(), familyAddress.IsLocation.ToString() );
                            groupLocation.IsMappedLocation = familyAddress.IsLocation;

                            if ( updatedAddress != null )
                            {
                                History.EvaluateChange( familyChanges, familyAddress.LocationTypeName + " Location",
                                    groupLocation.Location.ToString(), updatedAddress.ToString() );
                                groupLocation.Location = updatedAddress;
                            }

                            groupLocationService.Save( groupLocation, CurrentPersonId );

                            // Add the same locations to any new families created by removing an existing family member
                            if ( newFamilies.Any() )
                            {
                                //reload grouplocation for access to child properties
                                groupLocation = groupLocationService.Get( groupLocation.Id );
                                foreach ( var newFamily in newFamilies )
                                {
                                    var newFamilyLocation = new GroupLocation();
                                    newFamilyLocation.GroupId = newFamily.Id;
                                    newFamilyLocation.LocationId = groupLocation.LocationId;
                                    newFamilyLocation.GroupLocationTypeValueId = groupLocation.GroupLocationTypeValueId;
                                    newFamilyLocation.IsMailingLocation = groupLocation.IsMailingLocation;
                                    newFamilyLocation.IsMappedLocation = groupLocation.IsMappedLocation;
                                    groupLocationService.Add( newFamilyLocation, CurrentPersonId );
                                    groupLocationService.Save( newFamilyLocation, CurrentPersonId );
                                }
                            }
                        }

                        historyService.SaveChanges( typeof( Group ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                            _family.Id, familyChanges, CurrentPersonId );

                        _family = familyService.Get( _family.Id );
                        if ( _family.Members.Any( m => m.PersonId == Person.Id ) )
                        {
                            Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
                        }
                        else
                        {
                            var fm = _family.Members
                                .Where( m =>
                                    m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) &&
                                    m.Person.Gender == Gender.Male )
                                .OrderByDescending( m => m.Person.Age )
                                .FirstOrDefault();
                            if ( fm == null )
                            {
                                fm = _family.Members
                                    .Where( m =>
                                        m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) )
                                    .OrderByDescending( m => m.Person.Age )
                                    .FirstOrDefault();
                            }
                            if ( fm == null )
                            {
                                fm = _family.Members
                                    .OrderByDescending( m => m.Person.Age )
                                    .FirstOrDefault();
                            }
                            if ( fm != null )
                            {
                                Response.Redirect( string.Format( "~/Person/{0}", fm.PersonId ), false );
                            }
                            else
                            {
                                Response.Redirect( "~", false );
                            }
                        }

                    }
                } );
            }
        }
コード例 #28
0
            /// <summary>
            /// Called after the save operation has been executed
            /// </summary>
            /// <remarks>
            /// This method is only called if <see cref="M:Rock.Data.EntitySaveHook`1.PreSave" /> returns
            /// without error.
            /// </remarks>
            protected override void PostSave()
            {
                // Get the current person's alias ID from the current context.
                var currentPersonAliasId = DbContext.GetCurrentPersonAlias()?.Id;
                var connectionRequest    = this.Entity as ConnectionRequest;

                // Create and send the change notification message now that the connection request has been saved.
                var processConnectionRequestChangeMessage = GetProcessConnectionRequestChangeMessage(Entry, connectionRequest, currentPersonAliasId);

                processConnectionRequestChangeMessage.SendWhen(this.DbContext.WrappedTransactionCompletedTask);

                var rockContext = ( RockContext )this.RockContext;

                if (Entity.ConnectionStatus == null)
                {
                    Entity.ConnectionStatus = new ConnectionStatusService(rockContext).Get(Entity.ConnectionStatusId);
                }

                if (Entity.ConnectionStatus != null && Entity.ConnectionStatus.AutoInactivateState && Entity.ConnectionState != ConnectionState.Inactive)
                {
                    Entity.ConnectionState = ConnectionState.Inactive;
                    rockContext.SaveChanges();
                }

                var connectionStatusAutomationsQuery = new ConnectionStatusAutomationService(rockContext).Queryable().Where(a => a.SourceStatusId == Entity.ConnectionStatusId);

                if (this.Entity._runAutomationsInPostSaveChanges && connectionStatusAutomationsQuery.Any())
                {
                    var connectionStatusAutomationsList = connectionStatusAutomationsQuery.AsNoTracking().OrderBy(a => a.AutomationName).ToList();
                    var connectionStatusAutomations     = connectionStatusAutomationsList;
                    int changedStatusCount = 0;
                    foreach (var connectionStatusAutomation in connectionStatusAutomations)
                    {
                        if (this.Entity.processedConnectionStatusAutomations.Contains(connectionStatusAutomation.Id))
                        {
                            // to avoid recursion, skip over automations that have already been processed in this thread.
                            continue;
                        }

                        if (Entity.ConnectionStatusId == connectionStatusAutomation.DestinationStatusId)
                        {
                            // If already have this status, no need to figure out if it needs to be set to this status,
                            // or to set the status.
                            this.Entity.processedConnectionStatusAutomations.Add(connectionStatusAutomation.Id);
                            continue;
                        }

                        bool isAutomationValid = true;
                        if (connectionStatusAutomation.DataViewId.HasValue)
                        {
                            // Get the dataview configured for the connection request
                            var dataViewService = new DataViewService(rockContext);
                            var dataview        = dataViewService.Get(connectionStatusAutomation.DataViewId.Value);

                            if (dataview != null)
                            {
                                var dataViewQuery = new ConnectionRequestService(rockContext).GetQueryUsingDataView(dataview);
                                isAutomationValid = dataViewQuery.Any(a => a.Id == Entity.Id);
                            }
                        }

                        if (isAutomationValid && connectionStatusAutomation.GroupRequirementsFilter != GroupRequirementsFilter.Ignore)
                        {
                            // Group Requirement can't be meet when either placement group or placement group role id is missing
                            if (!Entity.AssignedGroupId.HasValue || !Entity.AssignedGroupMemberRoleId.HasValue)
                            {
                                isAutomationValid = false;
                            }
                            else
                            {
                                var isRequirementMeet   = true;
                                var group               = new GroupService(rockContext).Get(Entity.AssignedGroupId.Value);
                                var hasGroupRequirement = new GroupRequirementService(rockContext).Queryable().Where(a => (a.GroupId.HasValue && a.GroupId == group.Id) || (a.GroupTypeId.HasValue && a.GroupTypeId == group.GroupTypeId)).Any();
                                if (hasGroupRequirement)
                                {
                                    var requirementsResults = group.PersonMeetsGroupRequirements(
                                        rockContext,
                                        Entity.PersonAlias.PersonId,
                                        Entity.AssignedGroupMemberRoleId.Value);

                                    if (requirementsResults != null && requirementsResults
                                        .Where(a => a.MeetsGroupRequirement != MeetsGroupRequirement.NotApplicable)
                                        .Any(r =>
                                             r.MeetsGroupRequirement != MeetsGroupRequirement.Meets && r.MeetsGroupRequirement != MeetsGroupRequirement.MeetsWithWarning)
                                        )
                                    {
                                        isRequirementMeet = false;
                                    }
                                }

                                // connection request based on if group requirement is meet or not is added to list for status update
                                isAutomationValid = (connectionStatusAutomation.GroupRequirementsFilter == GroupRequirementsFilter.DoesNotMeet && !isRequirementMeet) ||
                                                    (connectionStatusAutomation.GroupRequirementsFilter == GroupRequirementsFilter.MustMeet && isRequirementMeet);
                            }
                        }

                        if (isAutomationValid)
                        {
                            if (Entity.SetConnectionStatusFromAutomationLoop(connectionStatusAutomation))
                            {
                                changedStatusCount++;
                                rockContext.SaveChanges();
                            }
                        }
                    }
                }

                var hasHistoryChanges       = HistoryChangeList?.Any() == true;
                var hasPersonHistoryChanges = PersonHistoryChangeList?.Any() == true;

                if (hasHistoryChanges || hasPersonHistoryChanges)
                {
                    using (var historyRockContext = new RockContext())
                    {
                        if (hasHistoryChanges)
                        {
                            HistoryService.SaveChanges(historyRockContext, typeof(ConnectionRequest), Rock.SystemGuid.Category.HISTORY_CONNECTION_REQUEST.AsGuid(), Entity.Id, HistoryChangeList, false, Entity.ModifiedByPersonAliasId);
                        }

                        if (hasPersonHistoryChanges)
                        {
                            var personId = Entity.PersonAlias?.PersonId ?? new PersonAliasService(rockContext).GetPersonId(Entity.PersonAliasId);
                            if (personId.HasValue)
                            {
                                HistoryService.SaveChanges(
                                    historyRockContext,
                                    typeof(Person),
                                    Rock.SystemGuid.Category.HISTORY_PERSON_CONNECTION_REQUEST.AsGuid(),
                                    personId.Value,
                                    PersonHistoryChangeList,
                                    "Request",
                                    typeof(ConnectionRequest),
                                    Entity.Id,
                                    false,
                                    Entity.ModifiedByPersonAliasId,
                                    rockContext.SourceOfChange);
                            }
                        }

                        historyRockContext.SaveChanges(false);
                    }
                }

                base.PostSave();
            }
コード例 #29
0
        /// <summary>
        /// Adds the new family address.
        /// </summary>
        /// <param name="rockContext">The rock context.</param>
        /// <param name="family">The family.</param>
        /// <param name="locationTypeGuid">The location type unique identifier.</param>
        /// <param name="street1">The street1.</param>
        /// <param name="street2">The street2.</param>
        /// <param name="city">The city.</param>
        /// <param name="state">The state.</param>
        /// <param name="postalCode">The postal code.</param>
        /// <param name="country">The country.</param>
        /// <param name="moveExistingToPrevious">if set to <c>true</c> [move existing to previous].</param>
        public static void AddNewFamilyAddress( RockContext rockContext, Group family, string locationTypeGuid,
            string street1, string street2, string city, string state, string postalCode, string country, bool moveExistingToPrevious = false )
        {
            if ( !String.IsNullOrWhiteSpace( street1 ) ||
                 !String.IsNullOrWhiteSpace( street2 ) ||
                 !String.IsNullOrWhiteSpace( city ) ||
                 !String.IsNullOrWhiteSpace( postalCode ) ||
                 !string.IsNullOrWhiteSpace( country ) )
            {
                var locationType = Rock.Web.Cache.DefinedValueCache.Read( locationTypeGuid.AsGuid() );
                if ( locationType != null )
                {
                    var location = new LocationService( rockContext ).Get( street1, street2, city, state, postalCode, country );
                    if ( location != null )
                    {
                        var groupLocationService = new GroupLocationService( rockContext );
                        if ( !groupLocationService.Queryable()
                            .Where( gl =>
                                gl.GroupId == family.Id &&
                                gl.GroupLocationTypeValueId == locationType.Id &&
                                gl.LocationId == location.Id )
                            .Any() )
                        {

                            var familyChanges = new List<string>();

                            if ( moveExistingToPrevious )
                            {
                                var prevLocationType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_PREVIOUS );
                                if ( prevLocationType != null )
                                {
                                    foreach ( var prevLoc in groupLocationService.Queryable( "Location,GroupLocationTypeValue" )
                                        .Where( gl =>
                                            gl.GroupId == family.Id &&
                                            gl.GroupLocationTypeValueId == locationType.Id ) )
                                    {
                                        History.EvaluateChange( familyChanges, prevLoc.Location.ToString(), prevLoc.GroupLocationTypeValue.Value, prevLocationType.Value );
                                        prevLoc.GroupLocationTypeValueId = prevLocationType.Id;
                                        prevLoc.IsMailingLocation = false;
                                        prevLoc.IsMappedLocation = false;
                                    }
                                }
                            }

                            string addressChangeField = locationType.Value;

                            var groupLocation = groupLocationService.Queryable()
                                .Where( gl =>
                                    gl.GroupId == family.Id &&
                                    gl.LocationId == location.Id )
                                .FirstOrDefault();
                            if ( groupLocation == null )
                            {
                                groupLocation = new GroupLocation();
                                groupLocation.Location = location;
                                groupLocation.IsMailingLocation = true;
                                groupLocation.IsMappedLocation = true;
                                family.GroupLocations.Add( groupLocation );
                            }
                            groupLocation.GroupLocationTypeValueId = locationType.Id;

                            History.EvaluateChange( familyChanges, addressChangeField, string.Empty, groupLocation.Location.ToString() );
                            History.EvaluateChange( familyChanges, addressChangeField + " Is Mailing", string.Empty, groupLocation.IsMailingLocation.ToString() );
                            History.EvaluateChange( familyChanges, addressChangeField + " Is Map Location", string.Empty, groupLocation.IsMappedLocation.ToString() );

                            rockContext.SaveChanges();

                            foreach ( var fm in family.Members )
                            {
                                HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                                    fm.PersonId, familyChanges, family.Name, typeof( Group ), family.Id );
                            }
                        }
                    }
                }
            }
        }
コード例 #30
0
        /// <summary>
        /// Saves the new family.
        /// </summary>
        /// <param name="rockContext">The rock context.</param>
        /// <param name="familyMembers">The family members.</param>
        /// <param name="campusId">The campus identifier.</param>
        /// <param name="savePersonAttributes">if set to <c>true</c> [save person attributes].</param>
        /// <returns></returns>
        public static Group SaveNewFamily( RockContext rockContext, List<GroupMember> familyMembers, int? campusId, bool savePersonAttributes )
        {
            var familyGroupType = GroupTypeCache.GetFamilyGroupType();

            var familyChanges = new List<string>();
            var familyMemberChanges = new Dictionary<Guid, List<string>>();
            var familyDemographicChanges = new Dictionary<Guid, List<string>>();

            if ( familyGroupType != null )
            {
                var groupService = new GroupService( rockContext );

                var familyGroup = new Group();

                familyGroup.GroupTypeId = familyGroupType.Id;

                familyGroup.Name = familyMembers.FirstOrDefault().Person.LastName + " Family";
                History.EvaluateChange( familyChanges, "Family", string.Empty, familyGroup.Name );

                if ( campusId.HasValue )
                {
                    History.EvaluateChange( familyChanges, "Campus", string.Empty, CampusCache.Read( campusId.Value ).Name );
                }
                familyGroup.CampusId = campusId;

                int? childRoleId = null;
                var childRole = new GroupTypeRoleService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) );
                if ( childRole != null )
                {
                    childRoleId = childRole.Id;
                }

                foreach ( var familyMember in familyMembers )
                {
                    var person = familyMember.Person;
                    if ( person != null )
                    {
                        familyGroup.Members.Add( familyMember );

                        var demographicChanges = new List<string>();
                        demographicChanges.Add( "Created" );

                        History.EvaluateChange( demographicChanges, "Record Type", string.Empty, person.RecordTypeValueId.HasValue ? DefinedValueCache.GetName( person.RecordTypeValueId.Value ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "Record Status", string.Empty, person.RecordStatusValueId.HasValue ? DefinedValueCache.GetName( person.RecordStatusValueId.Value ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "Record Status Reason", string.Empty, person.RecordStatusReasonValueId.HasValue ? DefinedValueCache.GetName( person.RecordStatusReasonValueId.Value ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "Connection Status", string.Empty, person.ConnectionStatusValueId.HasValue ? DefinedValueCache.GetName( person.ConnectionStatusValueId ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "Deceased", false.ToString(), ( person.IsDeceased ?? false ).ToString() );
                        History.EvaluateChange( demographicChanges, "Title", string.Empty, person.TitleValueId.HasValue ? DefinedValueCache.GetName( person.TitleValueId ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "First Name", string.Empty, person.FirstName );
                        History.EvaluateChange( demographicChanges, "Nick Name", string.Empty, person.NickName );
                        History.EvaluateChange( demographicChanges, "Middle Name", string.Empty, person.MiddleName );
                        History.EvaluateChange( demographicChanges, "Last Name", string.Empty, person.LastName );
                        History.EvaluateChange( demographicChanges, "Suffix", string.Empty, person.SuffixValueId.HasValue ? DefinedValueCache.GetName( person.SuffixValueId ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "Birth Date", null, person.BirthDate );
                        History.EvaluateChange( demographicChanges, "Gender", null, person.Gender );
                        History.EvaluateChange( demographicChanges, "Marital Status", string.Empty, person.MaritalStatusValueId.HasValue ? DefinedValueCache.GetName( person.MaritalStatusValueId ) : string.Empty );
                        History.EvaluateChange( demographicChanges, "Anniversary Date", null, person.AnniversaryDate );
                        History.EvaluateChange( demographicChanges, "Graduation Year", null, person.GraduationYear );
                        History.EvaluateChange( demographicChanges, "Email", string.Empty, person.Email );
                        History.EvaluateChange( demographicChanges, "Email Active", false.ToString(), ( person.IsEmailActive ?? false ).ToString() );
                        History.EvaluateChange( demographicChanges, "Email Note", string.Empty, person.EmailNote );
                        History.EvaluateChange( demographicChanges, "Email Preference", null, person.EmailPreference );
                        History.EvaluateChange( demographicChanges, "Inactive Reason Note", string.Empty, person.InactiveReasonNote );
                        History.EvaluateChange( demographicChanges, "System Note", string.Empty, person.SystemNote );

                        familyDemographicChanges.Add( person.Guid, demographicChanges );

                        var memberChanges = new List<string>();

                        string roleName = familyGroupType.Roles
                            .Where( r => r.Id == familyMember.GroupRoleId )
                            .Select( r => r.Name )
                            .FirstOrDefault();

                        History.EvaluateChange( memberChanges, "Role", string.Empty, roleName );
                        familyMemberChanges.Add( person.Guid, memberChanges );
                    }
                }

                groupService.Add( familyGroup );
                rockContext.SaveChanges();

                var personService = new PersonService( rockContext );

                foreach ( var groupMember in familyMembers )
                {
                    var person = groupMember.Person;

                    if ( savePersonAttributes )
                    {
                        var newValues = person.AttributeValues;

                        person.LoadAttributes();
                        foreach ( var attributeCache in person.Attributes.Select( a => a.Value ) )
                        {
                            string oldValue = person.GetAttributeValue( attributeCache.Key ) ?? string.Empty;
                            string newValue = string.Empty;
                            if ( newValues != null &&
                                newValues.ContainsKey( attributeCache.Key ) &&
                                newValues[attributeCache.Key] != null )
                            {
                                newValue = newValues[attributeCache.Key].Value ?? string.Empty;
                            }

                            if ( !oldValue.Equals( newValue ) )
                            {
                                History.EvaluateChange( familyDemographicChanges[person.Guid], attributeCache.Name,
                                    attributeCache.FieldType.Field.FormatValue( null, oldValue, attributeCache.QualifierValues, false ),
                                    attributeCache.FieldType.Field.FormatValue( null, newValue, attributeCache.QualifierValues, false ) );
                                Rock.Attribute.Helper.SaveAttributeValue( person, attributeCache, newValue );
                            }
                        }
                    }

                    person = personService.Get( groupMember.PersonId );
                    if ( person != null )
                    {
                        bool updateRequired = false;
                        if ( !person.Aliases.Any( a => a.AliasPersonId == person.Id ) )
                        {
                            person.Aliases.Add( new PersonAlias { AliasPersonId = person.Id, AliasPersonGuid = person.Guid } );
                            updateRequired = true;
                        }
                        var changes = familyDemographicChanges[person.Guid];
                        if ( groupMember.GroupRoleId != childRoleId )
                        {
                            person.GivingGroupId = familyGroup.Id;
                            updateRequired = true;
                            History.EvaluateChange( changes, "Giving Group", string.Empty, familyGroup.Name );
                        }

                        if ( updateRequired )
                        {
                            rockContext.SaveChanges();
                        }

                        HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
                            person.Id, changes );

                        HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                            person.Id, familyMemberChanges[person.Guid], familyGroup.Name, typeof( Group ), familyGroup.Id );

                        HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
                            person.Id, familyChanges, familyGroup.Name, typeof( Group ), familyGroup.Id );
                    }
                }

                return familyGroup;
            }

            return null;
        }
コード例 #31
0
        /// <summary>
        /// Updates the last login and writes to the person's history log
        /// </summary>
        /// <param name="userName">Name of the user.</param>
        public static void UpdateLastLogin(string userName)
        {
            if (!string.IsNullOrWhiteSpace(userName))
            {
                using (var rockContext = new RockContext())
                {
                    int? personId     = null;
                    bool impersonated = userName.StartsWith("rckipid=");

                    if (!impersonated)
                    {
                        var userLogin = new UserLoginService(rockContext).GetByUserName(userName);
                        if (userLogin != null)
                        {
                            userLogin.LastLoginDateTime = RockDateTime.Now;
                            personId = userLogin.PersonId;
                        }
                    }
                    else
                    {
                        var impersonationToken = userName.Substring(8);
                        personId = new PersonService(rockContext).GetByImpersonationToken(impersonationToken, false, null)?.Id;
                    }

                    if (personId.HasValue)
                    {
                        var relatedDataBuilder  = new System.Text.StringBuilder();
                        int?relatedEntityTypeId = null;
                        int?relatedEntityId     = null;

                        if (impersonated)
                        {
                            var impersonatedByUser = HttpContext.Current?.Session["ImpersonatedByUser"] as UserLogin;

                            relatedEntityTypeId = EntityTypeCache.GetId <Rock.Model.Person>();
                            relatedEntityId     = impersonatedByUser?.PersonId;

                            if (impersonatedByUser != null)
                            {
                                relatedDataBuilder.Append($" impersonated by { impersonatedByUser.Person.FullName }");
                            }
                        }

                        if (HttpContext.Current != null && HttpContext.Current.Request != null)
                        {
                            string cleanUrl = PersonToken.ObfuscateRockMagicToken(HttpContext.Current.Request.Url.AbsoluteUri);

                            // obfuscate the url specified in the returnurl, just in case it contains any sensitive information (like a rckipid)
                            Regex returnurlRegEx = new Regex(@"returnurl=([^&]*)");
                            cleanUrl = returnurlRegEx.Replace(cleanUrl, "returnurl=XXXXXXXXXXXXXXXXXXXXXXXXXXXX");

                            relatedDataBuilder.AppendFormat(" to <span class='field-value'>{0}</span>, from <span class='field-value'>{1}</span>",
                                                            cleanUrl, HttpContext.Current.Request.UserHostAddress);
                        }

                        var historyChangeList = new History.HistoryChangeList();
                        var historyChange     = historyChangeList.AddChange(History.HistoryVerb.Login, History.HistoryChangeType.Record, userName);

                        if (relatedDataBuilder.Length > 0)
                        {
                            historyChange.SetRelatedData(relatedDataBuilder.ToString(), null, null);
                        }

                        HistoryService.SaveChanges(rockContext, typeof(Rock.Model.Person), Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), personId.Value, historyChangeList, true);
                    }
                }
            }
        }
コード例 #32
0
        /// <summary>
        /// Process a refund for a transaction.
        /// </summary>
        /// <param name="transaction">The refund transaction.</param>
        /// <param name="amount">The amount.</param>
        /// <param name="reasonValueId">The reason value identifier.</param>
        /// <param name="summary">The summary.</param>
        /// <param name="process">if set to <c>true</c> [process].</param>
        /// <param name="batchNameSuffix">The batch name suffix.</param>
        /// <param name="errorMessage">The error message.</param>
        /// <returns></returns>
        public FinancialTransaction ProcessRefund(FinancialTransaction transaction, decimal?amount, int?reasonValueId, string summary, bool process, string batchNameSuffix, out string errorMessage)
        {
            errorMessage = string.Empty;

            // Validate parameters
            if (transaction == null)
            {
                errorMessage = "A valid transaction is required";
                return(null);
            }

            if (transaction.Batch == null)
            {
                errorMessage = "Transaction must belong to a batch";
                return(null);
            }

            if (!amount.HasValue || amount.Value <= 0.0m)
            {
                amount = transaction.TotalAmount;
            }

            if (!amount.HasValue || amount.Value <= 0.0m)
            {
                errorMessage = string.Format("Amount must be greater than {0}", 0.0m.FormatAsCurrency());
                return(null);
            }


            FinancialTransaction refundTransaction = null;

            // If processing the refund through gateway, get the gateway component and process a "Credit" transaction.
            if (process)
            {
                if (transaction.FinancialGateway == null || transaction.TransactionCode.IsNullOrWhiteSpace())
                {
                    errorMessage = "When processing the refund through the Gateway, the transaction must have a valid Gateway and Transaction Code";
                    return(null);
                }

                var gatewayComponent = transaction.FinancialGateway.GetGatewayComponent();
                if (gatewayComponent == null)
                {
                    errorMessage = "Could not get the Gateway component in order to process the refund";
                    return(null);
                }

                refundTransaction = gatewayComponent.Credit(transaction, amount.Value, summary, out errorMessage);
                if (refundTransaction == null)
                {
                    return(null);
                }
            }
            else
            {
                refundTransaction = new FinancialTransaction();
            }

            refundTransaction.AuthorizedPersonAliasId = transaction.AuthorizedPersonAliasId;
            refundTransaction.TransactionDateTime     = RockDateTime.Now;
            refundTransaction.FinancialGatewayId      = transaction.FinancialGatewayId;
            refundTransaction.TransactionTypeValueId  = transaction.TransactionTypeValueId;
            refundTransaction.SourceTypeValueId       = transaction.SourceTypeValueId;
            if (transaction.FinancialPaymentDetail != null)
            {
                refundTransaction.FinancialPaymentDetail = new FinancialPaymentDetail();
                refundTransaction.FinancialPaymentDetail.AccountNumberMasked      = transaction.FinancialPaymentDetail.AccountNumberMasked;
                refundTransaction.FinancialPaymentDetail.BillingLocationId        = transaction.FinancialPaymentDetail.BillingLocationId;
                refundTransaction.FinancialPaymentDetail.CreditCardTypeValueId    = transaction.FinancialPaymentDetail.CreditCardTypeValueId;
                refundTransaction.FinancialPaymentDetail.CurrencyTypeValueId      = transaction.FinancialPaymentDetail.CurrencyTypeValueId;
                refundTransaction.FinancialPaymentDetail.ExpirationMonthEncrypted = transaction.FinancialPaymentDetail.ExpirationMonthEncrypted;
                refundTransaction.FinancialPaymentDetail.ExpirationYearEncrypted  = transaction.FinancialPaymentDetail.ExpirationYearEncrypted;
                refundTransaction.FinancialPaymentDetail.NameOnCardEncrypted      = transaction.FinancialPaymentDetail.NameOnCardEncrypted;
            }

            decimal remainingBalance = amount.Value;

            foreach (var account in transaction.TransactionDetails.Where(a => a.Amount > 0))
            {
                var transactionDetail = new FinancialTransactionDetail();
                transactionDetail.AccountId    = account.AccountId;
                transactionDetail.EntityId     = account.EntityId;
                transactionDetail.EntityTypeId = account.EntityTypeId;
                refundTransaction.TransactionDetails.Add(transactionDetail);

                if (remainingBalance >= account.Amount)
                {
                    transactionDetail.Amount = 0 - account.Amount;
                    remainingBalance        -= account.Amount;
                }
                else
                {
                    transactionDetail.Amount = 0 - remainingBalance;
                    remainingBalance         = 0.0m;
                }

                if (remainingBalance <= 0.0m)
                {
                    break;
                }
            }

            if (remainingBalance > 0 && refundTransaction.TransactionDetails.Any())
            {
                refundTransaction.TransactionDetails.Last().Amount += remainingBalance;
            }

            var rockContext = this.Context as Rock.Data.RockContext;

            var registrationEntityType = EntityTypeCache.Get(typeof(Rock.Model.Registration));

            if (registrationEntityType != null)
            {
                foreach (var transactionDetail in refundTransaction.TransactionDetails
                         .Where(d =>
                                d.EntityTypeId.HasValue &&
                                d.EntityTypeId.Value == registrationEntityType.Id &&
                                d.EntityId.HasValue))
                {
                    var registrationChanges = new History.HistoryChangeList();
                    registrationChanges.AddChange(History.HistoryVerb.Process, History.HistoryChangeType.Record, $"{transactionDetail.Amount.FormatAsCurrency()} Refund");
                    HistoryService.SaveChanges(
                        rockContext,
                        typeof(Registration),
                        Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
                        transactionDetail.EntityId.Value,
                        registrationChanges
                        );
                }
            }

            refundTransaction.RefundDetails = new FinancialTransactionRefund();
            refundTransaction.RefundDetails.RefundReasonValueId   = reasonValueId;
            refundTransaction.RefundDetails.RefundReasonSummary   = summary;
            refundTransaction.RefundDetails.OriginalTransactionId = transaction.Id;

            string batchName = transaction.Batch.Name;

            if (batchNameSuffix.IsNotNullOrWhiteSpace() && !batchName.EndsWith(batchNameSuffix))
            {
                batchName += batchNameSuffix;
            }

            // Get the batch
            var      batchService = new FinancialBatchService(rockContext);
            TimeSpan timespan     = new TimeSpan();

            if (transaction.FinancialGateway != null)
            {
                timespan = transaction.FinancialGateway.GetBatchTimeOffset();
            }
            var batch = batchService.GetByNameAndDate(batchName, refundTransaction.TransactionDateTime.Value, timespan);

            // If this is a new Batch, SaveChanges so that we can get the Batch.Id
            if (batch.Id == 0)
            {
                rockContext.SaveChanges();
            }

            refundTransaction.BatchId = batch.Id;
            Add(refundTransaction);
            rockContext.SaveChanges();

            batchService.IncrementControlAmount(batch.Id, refundTransaction.TotalAmount, null);
            rockContext.SaveChanges();

            return(refundTransaction);
        }