prs/prs.desktop/Panels/Security/User/UserTokenGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Windows.Media.Imaging;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;

namespace PRSDesktop
{
    public class UserTokenGrid : DynamicGrid<UserTokenItem>
    {
        private Guid _groupid = Guid.Empty;

        private Guid _userid = Guid.Empty;
        private readonly BitmapImage defaultdisabled = PRSDesktop.Resources.disabled.Fade(0.25F).AsBitmapImage();
        private readonly BitmapImage defaulttick = PRSDesktop.Resources.tick.Fade(0.25F).AsBitmapImage();
        private readonly BitmapImage disabled = PRSDesktop.Resources.disabled.AsBitmapImage();

        private readonly BitmapImage tick = PRSDesktop.Resources.tick.AsBitmapImage();

        public UserTokenGrid()
        {
            Items = new List<UserTokenItem>();
            LoadSystemTokens();
            LoadGlobalTokens();

            ActionColumns.Add(new DynamicImageColumn(TokenImage, TokenAction)
            {
                GetFilter = () => new FuncCheckBoxDynamicGridColumnFilter(TokenFilter, TokenFilterData)
            });
            HiddenColumns.Add(x => x.Code);
            HiddenColumns.Add(x => x.Value);
            HiddenColumns.Add(x => x.Default);
            HiddenColumns.Add(x => x.HasValue);
        }

        protected override void Init()
        {
        }
        protected override void DoReconfigure(DynamicGridOptions options)
        {
            options.RecordCount = true;
            options.FilterRows = true;
        }

        public List<UserTokenItem> Items { get; }

        public List<UserSecurityToken> Tokens { get; private set; }

        public Guid GroupID
        {
            get => _groupid;
            set
            {
                _groupid = value;
                LoadGroupTokens();
            }
        }

        public Guid UserID
        {
            get => _userid;
            set
            {
                _userid = value;
                LoadUserTokens();
            }
        }

        private void LoadSystemTokens()
        {
            foreach (var descriptor in Security.Descriptors.Where(x => x.Visible && x.HasScope(SecurityDescriptorScope.User)))
            {
                var tokenitem = new UserTokenItem
                {
                    Group = descriptor.Type,
                    Code = descriptor.Code,
                    Description = descriptor.Description,
                    ID = Guid.Empty,
                    Default = descriptor.Value,
                    HasValue = false,
                    Value = descriptor.Value
                };
                Items.Add(tokenitem);
            }
        }

        private void LoadGlobalTokens()
        {
            var globaltokens = new Client<GlobalSecurityToken>().Load();
            foreach (var globaltoken in globaltokens)
            {
                globaltoken.Descriptor = globaltoken.Descriptor.Split('.').Last();
                var item = Items.FirstOrDefault(x => x.Code.Equals(globaltoken.Descriptor));
                if (item != null)
                {
                    item.Default = globaltoken.Enabled;
                    item.HasValue = false;
                    item.Value = globaltoken.Enabled;
                }
            }
        }

        private void LoadGroupTokens()
        {
            var grouptokens = new Client<SecurityToken>().Load(new Filter<SecurityToken>(x => x.Group.ID).IsEqualTo(_groupid));
            foreach (var grouptoken in grouptokens)
            {
                grouptoken.Descriptor = grouptoken.Descriptor.Split('.').Last();
                var item = Items.FirstOrDefault(x => x.Code.Equals(grouptoken.Descriptor));
                if (item != null)
                {
                    item.Default = grouptoken.Enabled;
                    item.HasValue = false;
                    item.Value = grouptoken.Enabled;
                }
            }
        }

        private void LoadUserTokens()
        {
            Tokens = new Client<UserSecurityToken>().Load(new Filter<UserSecurityToken>(x => x.User.ID).IsEqualTo(_userid)).ToList();
            foreach (var token in Tokens)
            {
                token.Descriptor = token.Descriptor.Split('.').Last();
                var item = Items.FirstOrDefault(x => x.Code.Equals(token.Descriptor));
                if (item != null)
                {
                    item.ID = token.ID;
                    item.HasValue = true;
                    item.Value = token.Enabled;
                }
            }
        }

        public override void DeleteItems(params CoreRow[] row)
        {
        }

        public override void SaveItem(UserTokenItem item)
        {
        }

        public override UserTokenItem LoadItem(CoreRow row)
        {
            return Items[row.Index];
        }

        protected override void Reload(
        	Filters<UserTokenItem> criteria, Columns<UserTokenItem> columns, ref SortOrder<UserTokenItem>? sort,
        	CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            var table = new CoreTable();
            table.LoadColumns(columns);
            table.LoadRows(Items);
            action.Invoke(table, null);
        }

        private IEnumerable<Tuple<string, object?>> TokenFilterData()
        {
            yield return new("Enabled", "Enabled");
            yield return new("Disabled", "Disabled");
            yield return new("Overriden", "Overriden");
        }

        private bool TokenFilter(CoreRow row, Predicate<object?> filter)
        {
            var hasvalue = row.Get<GroupTokenItem, bool>(x => x.HasValue);

            if (hasvalue && filter("Overriden")) return true;

            var value = row.Get<GroupTokenItem, bool>(x => x.Value);
            var defvalue = row.Get<GroupTokenItem, bool>(x => x.Default);

            var actualValue = hasvalue ? value : defvalue;

            if (actualValue)
            {
                return filter("Enabled");
            }
            else
            {
                return filter("Disabled");
            }
        }

        private bool TokenAction(CoreRow? row)
        {
            var result = false;
            var rows = row == null ? Data.Rows.ToArray() : new[] { row };
            foreach (var corrow in rows)
            {
                var Code = corrow.Get<UserTokenItem, string>(x => x.Code);

                var defvalue = corrow.Get<UserTokenItem, bool>(x => x.Default);
                var hasvalue = corrow.Get<UserTokenItem, bool>(x => x.HasValue);
                var actvalue = corrow.Get<UserTokenItem, bool>(x => x.Value);

                var token = Tokens.FirstOrDefault(x => x.Descriptor.Equals(Code));
                if (token == null)
                {
                    token = new UserSecurityToken();
                    token.Descriptor = Code;
                    token.User.ID = _userid;
                    Tokens.Add(token);
                }

                var item = Items.FirstOrDefault(x => x.Code.Equals(Code));
                if (item != null)
                {
                    // novalue -> !default -> default -> novalue
                    if (!item.HasValue)
                    {
                        item.Value = !item.Default;
                        item.HasValue = true;
                    }
                    else
                    {
                        if (item.Value != item.Default)
                            item.Value = item.Default;
                        else
                            item.HasValue = false;
                    }

                    token.Enabled = item.Value;
                    result = true;
                }
            }

            return result;
        }

        private BitmapImage TokenImage(CoreRow? row)
        {
            if (row == null)
                return tick;
            var defvalue = row.Get<UserTokenItem, bool>(x => x.Default);
            var hasvalue = row.Get<UserTokenItem, bool>(x => x.HasValue);
            var actvalue = row.Get<UserTokenItem, bool>(x => x.Value);

            return hasvalue ? actvalue ? tick : disabled : defvalue ? defaulttick : defaultdisabled;
        }

        protected override DynamicGridColumns LoadColumns()
        {
            var columns = new DynamicGridColumns();
            columns.Add(new DynamicGridColumn { ColumnName = "Group", Caption = "Group", Width = 100, Alignment = Alignment.MiddleLeft });
            columns.Add(new DynamicGridColumn { ColumnName = "Description", Caption = "Description", Width = 0, Alignment = Alignment.MiddleLeft });
            return columns;
        }
    }
}