prs/prs.desktop/Panels/Security/Groups/GroupTokenGrid.cs

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

namespace PRSDesktop
{
    public class GroupTokenGrid : DynamicGrid<GroupTokenItem>
    {
        private Guid _groupid = 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 GroupTokenGrid()
        {
            Items = new List<GroupTokenItem>();

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

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

            ActionColumns.Add(new DynamicImageColumn(TokenImage, TokenAction)
                { Filters = new[] { "Enabled", "Disabled", "Overridden" }, FilterRecord = TokenFilter });
            //ActionColumns.Add(new DynamicTickColumn<TokenItem,bool>(x => x.Checked, tick, tick, disabled) { Action = CheckClick, AllowHeaderClick = true });
            HiddenColumns.Add(x => x.Code);
            HiddenColumns.Add(x => x.Value);
            HiddenColumns.Add(x => x.HasValue);
            HiddenColumns.Add(x => x.Default);
        }

        protected override void Init()
        {
        }
        protected override void DoReconfigure(FluentList<DynamicGridOption> options)
        {
            options.AddRange(DynamicGridOption.RecordCount, DynamicGridOption.FilterRows);
        }

        public List<GroupTokenItem> Items { get; }

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

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

        private void LoadGroupTokens()
        {
            Tokens = new Client<SecurityToken>().Load(new Filter<SecurityToken>(x => x.Group.ID).IsEqualTo(_groupid)).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(GroupTokenItem item)
        {
        }

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

        protected override void Reload(Filters<GroupTokenItem> criteria, Columns<GroupTokenItem> columns, ref SortOrder<GroupTokenItem>? sort, Action<CoreTable?, Exception?> action)
        {
            var table = new CoreTable();
            foreach (var column in columns.Items)
                table.Columns.Add(new CoreColumn { ColumnName = column.ToString() });
            table.LoadRows(Items);
            action.Invoke(table, null);
        }

        private bool TokenFilter(CoreRow row, string[] filter)
        {
            
            var defvalue = row.Get<GroupTokenItem, bool>(x => x.Default);
            var hasvalue = row.Get<GroupTokenItem, bool>(x => x.HasValue);
            var actvalue = row.Get<GroupTokenItem, bool>(x => x.Value);

            bool bOK = false;

            if (filter.Contains("Enabled") && (hasvalue ? actvalue : defvalue))
                return true;

            if (filter.Contains("Disabled") && (hasvalue ? !actvalue : !defvalue))
                return true;

            if (filter.Contains("Overridden") && hasvalue)
                return true;

            return false;

        }

        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<GroupTokenItem, string>(x => x.Code);
                var defvalue = row.Get<GroupTokenItem, bool>(x => x.Default);
                var hasvalue = row.Get<GroupTokenItem, bool>(x => x.HasValue);
                var actvalue = row.Get<GroupTokenItem, bool>(x => x.Value);

                var token = Tokens.FirstOrDefault(x => x.Descriptor.Equals(Code));
                if (token == null)
                {
                    token = new SecurityToken();
                    token.Descriptor = Code;
                    token.Group.ID = _groupid;
                    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<GroupTokenItem, bool>(x => x.Default);
            var hasvalue = row.Get<GroupTokenItem, bool>(x => x.HasValue);
            var actvalue = row.Get<GroupTokenItem, 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;
        }
    }
}