Example #1
0
        /// <summary>
        /// Get all for module
        /// </summary>
        /// <param name="search"></param>
        /// <param name="sortOrder"></param>
        /// <param name="start"></param>
        /// <param name="length"></param>
        /// <param name="totalCount"></param>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public IEnumerable <TrackAuditsListViewModel> GetAllForModuleFiltered(string search, string sortOrder, int start,
                                                                              int length,
                                                                              out int totalCount, string moduleName)
        {
            if (moduleName.IsNullOrEmpty())
            {
                totalCount = 0;
                return(new List <TrackAuditsListViewModel>());
            }

            var module = TrackerContextsInMemory.GetAll().FirstOrDefault(x => x.Key.Equals(moduleName));

            if (!module.IsNull())
            {
                return(GetAllFiltered(search, sortOrder, start, length, out totalCount,
                                      new Dictionary <string, Type>
                {
                    {
                        module.Key, module.Value
                    }
                }));
            }
            totalCount = 0;
            return(new List <TrackAuditsListViewModel>());
        }
Example #2
0
        /// <summary>
        /// Modules
        /// </summary>
        /// <returns></returns>
        public IActionResult Modules()
        {
            var modules = TrackerContextsInMemory.GetAll().Select(x => x.Key);

            return(View(modules));
        }
Example #3
0
        /// <summary>
        /// Filter list
        /// </summary>
        /// <param name="search"></param>
        /// <param name="sortOrder"></param>
        /// <param name="start"></param>
        /// <param name="length"></param>
        /// <param name="totalCount"></param>
        /// <param name="targets"></param>
        /// <returns></returns>
        public IEnumerable <TrackAuditsListViewModel> GetAllFiltered(string search, string sortOrder, int start, int length, out int totalCount, Dictionary <string, Type> targets = null)
        {
            var data          = new List <TrackAuditsListViewModel>();
            var trackContexts = targets ?? TrackerContextsInMemory.GetAll();

            foreach (var item in trackContexts)
            {
                var context = (ITrackerDbContext)IoC.Resolve(item.Value);
                if (context == null)
                {
                    continue;
                }
                var items = context.TrackAudits
                            .AsNoTracking()
                            .GroupBy(x => x.RecordId)
                            .Select(grp => grp.OrderByDescending(d => d.Version).First())
                            .ToList()
                            .Select(o => new TrackAuditsListViewModel
                {
                    Id                  = o.Id,
                    Author              = o.Author,
                    ChangedString       = o.Changed.ToShortDateString(),
                    CreatedString       = o.Created.ToShortDateString(),
                    ModifiedBy          = o.ModifiedBy,
                    TypeFullName        = o.TypeFullName,
                    EntityName          = o.TypeFullName.Split(".").LastOrDefault(),
                    IsDeleted           = o.IsDeleted,
                    TrackEventType      = o.TrackEventType,
                    Version             = o.Version,
                    EventType           = o.TrackEventType.ToString(),
                    DatabaseContextName = o.DatabaseContextName,
                    RecordId            = o.RecordId,
                    ModuleName          = item.Key
                }).ToList();

                data.AddRange(items);
            }

            var result = data.Where(x =>
                                    search == null || x.Author != null && x.Author.ToLower().Contains(search.ToLower()) ||
                                    x.TypeFullName != null && x.TypeFullName.ToLower().Contains(search.ToLower()) ||
                                    x.UserName != null && x.UserName.ToLower().Contains(search.ToLower())).ToList();

            totalCount = result.Count;

            result = result.Skip(start).Take(length).ToList();

            switch (sortOrder)
            {
            case "changed":
                result = result.OrderBy(a => a.Changed).ToList();
                break;

            case "modifiedBy":
                result = result.OrderBy(a => a.ModifiedBy).ToList();
                break;

            case "trackEventType":
                result = result.OrderBy(a => a.TrackEventType).ToList();
                break;

            case "typeFullName":
                result = result.OrderBy(a => a.TypeFullName).ToList();
                break;

            case "version":
                result = result.OrderBy(a => a.Version).ToList();
                break;

            case "author DESC":
                result = result.OrderByDescending(a => a.Author).ToList();
                break;

            case "created DESC":
                result = result.OrderByDescending(a => a.Created).ToList();
                break;

            case "changed DESC":
                result = result.OrderByDescending(a => a.Changed).ToList();
                break;

            case "modifiedBy DESC":
                result = result.OrderByDescending(a => a.ModifiedBy).ToList();
                break;

            case "trackEventType DESC":
                result = result.OrderByDescending(a => a.TrackEventType).ToList();
                break;

            case "typeFullName DESC":
                result = result.OrderByDescending(a => a.TypeFullName).ToList();
                break;

            case "version DESC":
                result = result.OrderByDescending(a => a.Version).ToList();
                break;

            default:
                result = result.AsQueryable().ToList();
                break;
            }

            return(result);
        }