Ejemplo n.º 1
0
        public async Task <long> UpdateHistoryChangeAsync(HistoryChangeDto historyChangeDto)
        {
            var historyChange = new HistoryChange();

            Mapper.Map(historyChangeDto, historyChange);
            var rowsUpdated = await historyChangeRepository.UpdateHistoryChangeAsync(historyChange, historyChangeDto.MappingScheme);

            return(rowsUpdated);
        }
        public async Task <long> UpdateHistoryChangeAsync(HistoryChange historyChange, string mappingScheme)
        {
            historyChangeMappingSchemeRegistrator.Register();
            var updatedHistoryChange = unitOfWork.Add(historyChange, mappingScheme);

            await unitOfWork.SaveAsync();

            return(updatedHistoryChange.Id);
        }
        public async Task <IActionResult> AddHistory(int countI, string userId, string documentId, string datetime, string documentStatus)
        {
            int count = _context.HistoryChanges.Count() + 1 + countI;

            HistoryChange hs = new HistoryChange()
            {
                Id                 = "HS_" + count,
                UserId             = userId,
                SecurityDocumentId = documentId,
                Date               = DateTime.Parse(datetime),
                DocumentStatus     = (DocumentStatus)Enum.Parse(typeof(DocumentStatus), documentStatus)
            };

            _context.HistoryChanges.Add(hs);
            await _context.SaveChangesAsync();

            return(Ok());
        }
Ejemplo n.º 4
0
        public void AppendDiff(string propertyName, Func <Issue, object> getValueExpression)
        {
            var value1 = getValueExpression(_issue1).ToString();
            var value2 = getValueExpression(_issue2).ToString();

            if (value1 == value2)
            {
                return;
            }

            var change = new HistoryChange
            {
                FieldName   = propertyName,
                ValueBefore = value1,
                ValueAfter  = value2,
            };

            _changes.Add(change);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Determines whether [has event happened] [the specified entity].
        /// </summary>
        /// <param name="followingEvent">The following event.</param>
        /// <param name="entity">The entity.</param>
        /// <param name="lastNotified">The last notified.</param>
        /// <returns></returns>
        public override bool HasEventHappened(FollowingEventType followingEvent, IEntity entity, DateTime?lastNotified)
        {
            if (followingEvent != null && entity != null)
            {
                var personAlias = entity as PersonAlias;

                if (personAlias != null && personAlias.Person != null)
                {
                    //
                    // Get all the attributes/settings we need.
                    //
                    int    daysBack         = GetAttributeValue(followingEvent, "MaxDaysBack").AsInteger();
                    string targetOldValue   = GetAttributeValue(followingEvent, "OldValue") ?? string.Empty;
                    string targetNewValue   = GetAttributeValue(followingEvent, "NewValue") ?? string.Empty;
                    string targetPersonGuid = GetAttributeValue(followingEvent, "Person");
                    bool   negateChangedBy  = GetAttributeValue(followingEvent, "NegatePerson").AsBoolean();
                    bool   matchBothValues  = GetAttributeValue(followingEvent, "MatchBoth").AsBoolean();
                    var    attributes       = GetAttributeValue(followingEvent, "Fields").Split(',').Select(a => a.Trim());

                    //
                    // Populate all the other random variables we need for processing.
                    //
                    PersonAlias targetPersonAlias  = new PersonAliasService(new RockContext()).Get(targetPersonGuid.AsGuid());
                    DateTime    daysBackDate       = RockDateTime.Now.AddDays(-daysBack);
                    var         person             = personAlias.Person;
                    int         personEntityTypeId = EntityTypeCache.Read(typeof(Person)).Id;
                    int         categoryId         = CategoryCache.Read(Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid()).Id;

                    //
                    // Start building the basic query. We want all History items that are for
                    // people objects and use the Demographic Changes category.
                    //
                    var qry = new HistoryService(new RockContext()).Queryable()
                              .Where(h => h.EntityTypeId == personEntityTypeId && h.EntityId == person.Id && h.CategoryId == categoryId);

                    //
                    // Put in our limiting dates. We always limit by our days back date,
                    // and conditionally limit based on the last time we notified the
                    // stalker - I mean the follower.
                    //
                    if (lastNotified.HasValue)
                    {
                        qry = qry.Where(h => h.CreatedDateTime >= lastNotified.Value);
                    }
                    qry = qry.Where(h => h.CreatedDateTime >= daysBackDate);

                    //
                    // Walk each history item found that matches our filter.
                    //
                    Dictionary <string, List <HistoryChange> > changes = new Dictionary <string, List <HistoryChange> >();
                    foreach (var history in qry.ToList())
                    {
                        Match modified = Regex.Match(history.Summary, ModifiedRegex);
                        Match added    = Regex.Match(history.Summary, AddedRegex);
                        Match deleted  = Regex.Match(history.Summary, DeletedRegex);

                        //
                        // Walk each attribute entered by the user to match against.
                        //
                        foreach (var attribute in attributes)
                        {
                            HistoryChange change = new HistoryChange();
                            string        title  = null;

                            //
                            // Check what kind of change this was.
                            //
                            if (modified.Success)
                            {
                                title      = modified.Groups[1].Value;
                                change.Old = modified.Groups[2].Value;
                                change.New = modified.Groups[3].Value;
                            }
                            else if (added.Success)
                            {
                                title      = added.Groups[1].Value;
                                change.Old = string.Empty;
                                change.New = added.Groups[2].Value;
                            }
                            else if (deleted.Success)
                            {
                                title      = deleted.Groups[1].Value;
                                change.Old = deleted.Groups[2].Value;
                                change.New = string.Empty;
                            }

                            //
                            // Check if this is one of the attributes we are following.
                            //
                            if (title != null && title.Trim() == attribute)
                            {
                                //
                                // Get the ValuePair object to work with.
                                //
                                if (!changes.ContainsKey(attribute))
                                {
                                    changes.Add(attribute, new List <HistoryChange>());
                                }

                                change.PersonId = history.CreatedByPersonId;
                                changes[attribute].Add(change);

                                //
                                // If the value has been changed back to what it was then ignore the change.
                                //
                                if (changes[attribute].Count >= 2)
                                {
                                    var changesList = changes[attribute].ToList();

                                    if (changesList[changesList.Count - 2].Old == changesList[changesList.Count - 1].New)
                                    {
                                        changes.Remove(title);
                                    }
                                }
                            }
                        }
                    }

                    //
                    // Walk the list of final changes and see if we need to notify.
                    //
                    foreach (var items in changes.Values)
                    {
                        foreach (HistoryChange change in items)
                        {
                            //
                            // Check for a match on the person who made the change.
                            //
                            if (targetPersonAlias == null ||
                                targetPersonAlias.Id == 0 ||
                                (!negateChangedBy && targetPersonAlias.PersonId == change.PersonId) ||
                                (negateChangedBy && targetPersonAlias.PersonId != change.PersonId))
                            {
                                bool oldMatch = (string.IsNullOrEmpty(targetOldValue) || targetOldValue == change.Old);
                                bool newMatch = (string.IsNullOrEmpty(targetNewValue) || targetNewValue == change.New);

                                //
                                // If the old value and the new value match then trigger the event.
                                //
                                if ((matchBothValues && oldMatch && newMatch) ||
                                    (!matchBothValues && (oldMatch || newMatch)))
                                {
                                    return(true);
                                }
                            }
                        }
                    }
                }
            }

            return(false);
        }
Ejemplo n.º 6
0
 protected bool Equals(HistoryChange other)
 {
     return(HistoryEntry.Equals(other.HistoryEntry));
 }
Ejemplo n.º 7
0
 public void AddHistoryChange(HistoryChange historyChange)
 {
     _db.HistoryChanges.Add(historyChange);
     _db.SaveChanges();
 }