prs/prs.mobile/comal.timesheets/MobileDataGrid.xaml.cs

using comal.timesheets.Data_Classes;
using comal.timesheets.Deliveries;
using InABox.Clients;
using InABox.Core;
using Syncfusion.XForms.PopupLayout;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Reflection;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;

namespace comal.timesheets
{
    public enum DataGridSaveType
    {
        None,
        Single,
        Multiple
    }

    public delegate void DataGridOptionsSet(string title, DataGridSaveType savetype = DataGridSaveType.None);
    public delegate void DataGridItemSelected(DataGridViewModelItem item);
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class MobileDataGrid : ContentView
    {
        public event DataGridOptionsSet OnOptionsSet;
        public event DataGridItemSelected OnItemSelected;

        public List<DataGridViewModelItem> Items { get; set; }
        DataGridSaveType SaveType { get; set; }
      
        bool bSearching = false;
        ObservableCollection<DataGridFilter> Filters = new ObservableCollection<DataGridFilter>();       
        List<DataGridViewModelItem> CurrentItems = new List<DataGridViewModelItem>();
        PropertyInfo[] info = typeof(DataGridViewModelItem).GetProperties();
        Dictionary<string, List<string>> FilterOptions = new Dictionary<string, List<string>>();
        Type Type;
        SfPopupLayout popupLayout;
        public MobileDataGrid()
        {
            InitializeComponent();
            Items = new List<DataGridViewModelItem>();
            Filters.CollectionChanged += Filters_CollectionChanged;

            popupLayout = new SfPopupLayout();
            popupLayout.PopupView.WidthRequest = 600;
            popupLayout.PopupView.HeightRequest = 600;
            popupLayout.PopupView.HeaderTitle = "Image";
            popupLayout.PopupView.AcceptButtonText = "Close";
        }

        #region Grid Setup
        public void Setup(List<DataGridViewModelItem> items, Type type, DataGridSaveType savetype = DataGridSaveType.None)
        {
            Type = type;
            Items = items;
            Device.BeginInvokeOnMainThread(() =>
            {
                SetupHeaders(items.First());
                Refresh(Items);
            });
            OnOptionsSet?.Invoke(type.Name, savetype);
            SaveType = savetype;
        }

        /// <summary>
        /// Never pass CurrentItems into this function - create an intermediate list first
        /// </summary>
        /// <param name="items"></param>
        private void Refresh(List<DataGridViewModelItem> items)
        {
            itemsListView.ItemsSource = items;
            countLbl.Text = items.Count + " Records";
            CurrentItems.Clear();
            foreach (var item in items)
            {
                CurrentItems.Add(item);
            }
            if (Filters.Any())
                filterBtnRow.Height = 80;
            else
                filterBtnRow.Height = 0;


            int count = 0;
            foreach (var column in Items.First().Data)
            {
                var filter = Filters.FirstOrDefault(x => x.ColNumber == "Col" + count);
                if (filter != null)
                    ChangeHeaderColour(true, count);
                else
                    ChangeHeaderColour(false, count);
                count++;
            }
        }

        public void SetupHeaders(DataGridViewModelItem item)
        {
            var count = GenerateHeaders(item);
            GenerateImageHeader(item, count);
        }

        public int GenerateHeaders(DataGridViewModelItem item)
        {
            int count = 0;
            foreach (var tuple in item.Data)
            {
                CreateNewHeader(tuple.Item1, count);
                CreateFilterOption(count);
                count++;
            }
            return count;
        }

        private void GenerateImageHeader(DataGridViewModelItem item, int count)
        {
            if (item.Image != null)
            {
                headerGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
                DataGridHeaderRow header = new DataGridHeaderRow { ColumnName = "Image", ColumnNumber = count };
                header.Setup();
                headerGrid.Children.Add(SetGridValues(header, 0, count));
                CreateSearchEntry("Image", count);
            }
        }

        private void CreateNewHeader(string name, int count)
        {
            headerGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
            DataGridHeaderRow header = new DataGridHeaderRow { ColumnName = name, ColumnNumber = count };
            header.Setup();
            header.OnDataGridHeaderFilterTapped += Header_OnDataGridHeaderFilterTapped;
            header.OnDataGridHeaderTapped += Header_OnDataGridHeaderTapped;
            headerGrid.Children.Add(SetGridValues(header, 0, count));
            CreateSearchEntry(name, count);
        }
        private void CreateFilterOption(int column)
        {
            List<string> options = new List<string>();
            foreach (var property in info)
            {
                if (property.Name == "Col" + column)
                    foreach (var item in Items)
                    {
                        string value = GetStringValue(property, item);
                        if (!options.Contains(value) && !string.IsNullOrWhiteSpace(value))
                            options.Add(value);
                    }
            }
            options.Sort();
            FilterOptions.Add("Col" + column, options);
        }      

        private void CreateSearchEntry(string name, int count)
        {
            var searchEnt = new DataGridSearchEntry(name, count);
            searchEnt.OnDataGridSearchEntryChanged += SearchEnt_OnDataGridSearchEntryChanged;
            searchEnt.IsEnabled = name == "Image" ? false : true;
            headerGrid.Children.Add(SetGridValues(searchEnt, 1, count));
        }

        private View SetGridValues(View view, int row, int column)
        {
            view.SetValue(Grid.RowProperty, row);
            view.SetValue(Grid.ColumnProperty, column);
            return view;
        }
        #endregion

        #region Events
        private void Row_Tapped(object sender, EventArgs e)
        {
            var item = itemsListView.SelectedItem as DataGridViewModelItem;
            if (item == null)
                return;
            if (SaveType != DataGridSaveType.None)
            {
                switch (SaveType)
                {
                    case DataGridSaveType.Single:
                        AddSelectionToLists(item);
                        UnselectOthers(item);
                        break;
                    case DataGridSaveType.Multiple:
                        AddSelectionToLists(item);
                        break;

                }
                List<DataGridViewModelItem> list = new List<DataGridViewModelItem>();
                foreach (var i in CurrentItems)
                    list.Add(i);
                Refresh(list);
            }
            else if (SaveType == DataGridSaveType.None)
            {
                OnItemSelected?.Invoke(item);
            }        
        }

        private void UnselectOthers(DataGridViewModelItem item)
        {
            UnselectItems(item, Items);
            UnselectItems(item, CurrentItems);
        }

        private void Image_Tapped(object sender, EventArgs e)
        {
            var item = ((TappedEventArgs)e).Parameter as DataGridViewModelItem;
            if (item == null)
                return;

            if (item.ImageID == Guid.Empty)
                return;

            CoreTable table = new Client<Document>().Query(new Filter<Document>(x => x.ID).IsEqualTo(item.ImageID),
            new Columns<Document>(x => x.Data));
            CoreRow docrow = table.Rows.FirstOrDefault();
            if (docrow != null)
            {
                byte[] data = docrow.Get<Document, byte[]>(x => x.Data);
                ImageSource src = ImageSource.FromStream(() => new MemoryStream(data));
                if (src != null)
                {
                    Image popupContent = new Image();
                    popupContent.HorizontalOptions = LayoutOptions.FillAndExpand;
                    popupContent.VerticalOptions = LayoutOptions.FillAndExpand;
                    popupContent.Aspect = Aspect.AspectFit;
                    popupContent.Source = src;
                    popupLayout.PopupView.ContentTemplate = new DataTemplate(() =>
                    {
                        return popupContent;
                    });
                    Device.BeginInvokeOnMainThread(() => { popupLayout.Show(); });
                   
                }
            }
        }

        private void UnselectItems(DataGridViewModelItem item, List<DataGridViewModelItem> selectedlist)
        {
            var list = selectedlist.Where(x => x.IsSelected == true);
            foreach (var foundItem in list)
            {
                if (foundItem.ID != item.ID)
                    foundItem.IsSelected = false;
            }
        }

        private void AddSelectionToLists(DataGridViewModelItem item)
        {
            bool selected = item.IsSelected;

            AddSelectionToList(selected, Items, item.ID);
            AddSelectionToList(selected, CurrentItems, item.ID);            
        }

        private void AddSelectionToList(bool selected, List<DataGridViewModelItem> list, Guid ID)
        {
            var foundItem = list.FirstOrDefault(x => x.ID == ID);
            if (foundItem != null)
                foundItem.IsSelected = selected ? false : true;
        }

        private void SearchEnt_OnDataGridSearchEntryChanged(int columnnumber, string value, string colname)
        {
            if (string.IsNullOrWhiteSpace(value))
                Filters.Remove(Filters.FirstOrDefault(x => x.ColNumber == "Col" + columnnumber && x.FilterType == FilterType.Typed));
            else
            {
                if (Filters.FirstOrDefault(x => x.ColNumber == "Col" + columnnumber) != null)
                    Filters.Remove(Filters.FirstOrDefault(x => x.ColNumber == "Col" + columnnumber && x.FilterType == FilterType.Typed));
                Filters.Add(new DataGridFilter(colname, "Col" + columnnumber, value, FindNumber(columnnumber), FilterType.Typed));
            }
        }


        private void Filters_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (bSearching)
                return;

            CheckFilterDisplay();

            bSearching = true;

            List<DataGridViewModelItem> finalList = new List<DataGridViewModelItem>();

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.Zero) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.Zero);
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(Items, foundfilter.Value, "Col0"))
                        finalList.Add(item);
                }
            }
            else
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.One) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.One);
                List<DataGridViewModelItem> intermediatelist = new List<DataGridViewModelItem>();
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(finalList, foundfilter.Value, "Col1"))
                        intermediatelist.Add(item);
                }
                finalList.Clear();
                foreach (DataGridViewModelItem item in intermediatelist)
                    finalList.Add(item);
            }
            else if (finalList.Count == 0)
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.Two) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.Two);
                List<DataGridViewModelItem> intermediatelist = new List<DataGridViewModelItem>();
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(finalList, foundfilter.Value, "Col2"))
                        intermediatelist.Add(item);
                }
                finalList.Clear();
                foreach (DataGridViewModelItem item in intermediatelist)
                    finalList.Add(item);
            }
            else if (finalList.Count == 0)
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.Three) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.Three);
                List<DataGridViewModelItem> intermediatelist = new List<DataGridViewModelItem>();
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(finalList, foundfilter.Value, "Col3"))
                        intermediatelist.Add(item);
                }
                finalList.Clear();
                foreach (DataGridViewModelItem item in intermediatelist)
                    finalList.Add(item);
            }

            if (finalList.Count == 0 && Filters.Count == 0)
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }
            else if (finalList.Count == Items.Count && Filters.Count > 0)
                finalList.Clear();

            Refresh(finalList);

            bSearching = false;
        }

        private void CheckFilterDisplay()
        {
            filterLayout.Children.Clear();
            foreach (var filter in Filters)
            {
                DataGridFilterView filterview = new DataGridFilterView(filter.DisplayValue, filter.FilterType, filter.ColNumber);
                filterview.OnFilterClosed += Filterview_OnFilterClosed;
                filterLayout.Children.Add(filterview);
            }
        }

        private void Filterview_OnFilterClosed(string value, FilterType type, string colnumber)
        {
            List<DataGridFilter> toRemove = new List<DataGridFilter>();
            foreach (var child in filterLayout.Children)
            {
                if (child.GetType() == typeof(DataGridFilterView))
                {
                    if ((child as DataGridFilterView).Value == value && (child as DataGridFilterView).FilterType == type)
                    {
                        var filter = Filters.FirstOrDefault(x => x.DisplayValue == value && x.FilterType == type);
                        if (filter != null)
                            toRemove.Add(filter);
                    }

                }
            }
            if (toRemove.First().FilterType == FilterType.Typed)
            {
                foreach (var child in headerGrid.Children)
                {
                    if (child.GetType() == typeof(DataGridSearchEntry))
                    {
                        if ((child as DataGridSearchEntry).ColumnNumber == int.Parse(colnumber.Substring(3, 1)))
                            (child as DataGridSearchEntry).Text = "";
                    }
                }
            }
            Filters.Remove(toRemove.First());
        }

        private void Header_OnDataGridHeaderTapped(int columnnumber, SearchUtils.SortDirection sortdirection)
        {
            var intermediatelist = new List<DataGridViewModelItem>();
            foreach (var property in info)
            {
                if (property.Name == "Col" + columnnumber)
                {
                    foreach (var item in SearchUtils.OrderByPropertyName(CurrentItems, "Col" + columnnumber, sortdirection))
                    {
                        intermediatelist.Add(item);
                    }
                    Refresh(intermediatelist);
                }
            }
        }

        private void Header_OnDataGridHeaderFilterTapped(int columnnumber, string columnname)
        {
            List<string> options = FilterOptions["Col" + columnnumber];
            List<DataGridFilter> filters = new List<DataGridFilter>();
            var selectedFilters = Filters.Where(x => x.FilterType == FilterType.Selected && x.ColNumber == "Col" + columnnumber);
            foreach (var list in selectedFilters)
            {
                filters.Add(list);
            }
            MultiSelectPage filterpage = new MultiSelectPage(options, filters, columnnumber, columnname);
            filterpage.OnPageSaved += FilterPage_OnPageSaved;
            Navigation.PushAsync(filterpage);
        }

        private void FilterPage_OnPageSaved(IEnumerable<MultiSelectPageViewItem> items, int columnnumber, string columnname)
        {
            var intermediateList = new List<DataGridFilter>();
            var list = Filters.Where(x => x.ColNumber == "Col" + columnnumber && x.FilterType == FilterType.Selected);
            foreach (var item in list)
            {
                intermediateList.Add(item);
            }
            foreach (var filter in intermediateList)
                Filters.Remove(filter);

            foreach (var item in items)
                Filters.Add(new DataGridFilter(columnname, "Col" + columnnumber, item.Value, FindNumber(columnnumber), FilterType.Selected));

            var newlist = Filters.Where(x => x.ColNumber == "Col" + columnnumber);
        }
        #endregion

        #region Utils
        private IEnumerable<DataGridViewModelItem> RunSearch(IEnumerable<DataGridViewModelItem> list, string value, string propertyname)
        {
            var intermediatelist = new List<DataGridViewModelItem>();
            foreach (var property in info)
            {
                if (property.Name == propertyname)
                {
                    foreach (var item in list)
                    {
                        if (GetStringValue(property, item).Contains(value)
                            || GetStringValue(property, item).Contains(value.ToUpper())
                            || GetStringValue(property, item).Contains(value.ToLower())
                            || GetStringValue(property, item).Contains(SearchUtils.LowerCaseFirst(value))
                            || GetStringValue(property, item).Contains(SearchUtils.UpperCaseFirst(value))
                            || GetStringValue(property, item).Contains(SearchUtils.UpperCaseSecond(value))
                            )
                        {
                            if (!intermediatelist.Contains(item))
                                intermediatelist.Add(item);
                        }
                    }
                }
            }
            return intermediatelist;
        }
        private void ChangeHeaderColour(bool filterpresent, int colnumber)
        {
            foreach (var header in headerGrid.Children)
            {
                if (header.GetType() == typeof(DataGridHeaderRow))
                {
                    if ((header as DataGridHeaderRow).ColumnNumber == colnumber)
                        (header as DataGridHeaderRow).ChangeFilterColour(filterpresent);
                }
            }
        }
        private string GetStringValue(PropertyInfo property, object item)
        {
            if (property.PropertyType == typeof(string))
                return (string)property.GetValue(item);
            else
                return "";
        }

        private FilterNumber FindNumber(int columnnumber)
        {
            switch (columnnumber)
            {
                case 0:
                    return FilterNumber.Zero;
                case 1:
                    return FilterNumber.One;
                case 2:
                    return FilterNumber.Two;
                case 3:
                    return FilterNumber.Three;
                default:
                    return FilterNumber.Zero;
            }
        }
        #endregion
    }

    public enum FilterNumber
    {
        Zero,
        One,
        Two,
        Three
    }
    public enum FilterType
    {
        Typed,
        Selected
    }

    public class DataGridFilter
    {
        public string ColNumber { get; set; }
        public string ColName { get; set; }
        public string Value { get; set; }
        public FilterNumber FilterNumber { get; set; }
        public FilterType FilterType { get; set; }
        public string DisplayValue
        {
            get => ColName + " = " + Value;
        }
        public DataGridFilter(string colname, string colNumber, string value, FilterNumber filterNumber, FilterType filterType)
        {
            ColName = colname;
            ColNumber = colNumber;
            Value = value;
            FilterNumber = filterNumber;
            FilterType = filterType;
        }
    }
    public class DataGridViewModelItem
    {
        public Guid ID { get; set; }
        public Guid ImageID { get; set; }

        private bool isSelected;
        public bool IsSelected
        {
            get
            {
                return isSelected;
            }
            set
            {
                isSelected = value;
                Color = isSelected == true ? Color.FromHex("#91a3b0") /*Cadet Gray*/ : Color.Default;
            }
        }
        public Color Color { get; set; }

        public List<Tuple<string, string>> Data { get; set; }
        public string Col0 { get; set; }
        public string Col1 { get; set; }
        public string Col2 { get; set; }
        public string Col3 { get; set; }
        public Image Image { get; set; }
        public ImageSource Source
        {
            get
            {
                return Image == null? null: Image.Source;
            }
        }
        public GridLength ColWidth0 { get; set; }
        public GridLength ColWidth1 { get; set; }
        public GridLength ColWidth2 { get; set; }
        public GridLength ColWidth3 { get; set; }
        public GridLength ImageColWidth { get; set; }
        public bool ImageColVisible { get; set; }

        public DataGridViewModelItem(Guid id, List<Tuple<string, string>> data, Image image = null, Guid imageid = new Guid())
        {
            ID = id;
            ImageID = imageid;
            Data = data;
            Image = image;
            Col0 = data.Count > 0 ? data[0].Item2 : "";
            Col1 = data.Count > 1 ? data[1].Item2 : "";
            Col2 = data.Count > 2 ? data[2].Item2 : "";
            Col3 = data.Count > 3 ? data[3].Item2 : "";
            ImageColWidth = image != null ? new GridLength(0.5, GridUnitType.Star) : new GridLength(0, GridUnitType.Absolute);
            ImageColVisible = image != null ? true : false;
            ColWidth0 = data.Count > 0 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Absolute);
            ColWidth1 = data.Count > 1 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Absolute);
            ColWidth2 = data.Count > 2 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Absolute);
            ColWidth3 = data.Count > 3 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Absolute);
            IsSelected = false;
        }
    }
}