prs/prs.desktop/Panels/Jobs/DocumentSets/JobDocumentSetPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;
using Inflector;
using Color = System.Drawing.Color;
using InABox.Configuration;

namespace PRSDesktop
{
    
    public class JobDocumentSetSettings : BaseObject, IGlobalConfigurationSettings
    {
        [Caption("Milestone Task",IncludePath = false)]
        public KanbanTypeLink DocumentMilestoneKanbanType { get; set; }

    }
    
    public partial class JobDocumentSetPanel : UserControl, IMasterDetailControl<Job>, IDataModelSource, IPanel<Job>
    {
        private enum Suppress
        {
            This
        }

        private JobDocumentSetSettings _settings = new();

        public Job? Master { get; set; }
        
        public JobDocumentSetPanel()
        {
            using (new EventSuppressor(Suppress.This))
                InitializeComponent();
        }

        public string SectionName => "Job Document Set";

        public DataModel DataModel(Selection selection)
        {
            var ids = Documents.Data != null ? Documents.Data.ExtractValues<JobDocumentSet, Guid>(x => x.ID).ToArray() : new Guid[] { };
            return new AutoDataModel<JobDocumentSet>(new Filter<JobDocumentSet>(x => x.ID).InList(ids));
        }

        public event DataModelUpdateEvent? OnUpdateDataModel;
        
        private static bool GetAreas(CoreTable areas, ComboBox target) //, RowDefinition row)
        {
            using (new EventSuppressor(Suppress.This))
            {
                Dictionary<Guid, String> result = new Dictionary<Guid, String>()
                {
                    { Guid.Empty, "" } //$"All {type.ToString().Pluralize()}" }
                };
                areas.IntoDictionary<JobITP, Guid, String>(result, x => x.ID,
                    (r) => $"{r.Get<JobITP, String>(c => c.Code)}: {r.Get<JobITP, String>(c => c.Description)}");

                // row.Height = result.Count > 1
                //     ? new GridLength(1, GridUnitType.Auto)
                //     : new GridLength(0, GridUnitType.Pixel);

                var value = target.SelectedValue;
                target.ItemsSource = result;
                target.SelectedValue = value;
                return result.Count > 1;
            }
        }

        private static bool GetTags(CoreTable tags, JobDocumentSetTagType type, ComboBox target) //, RowDefinition row)
        {
            using (new EventSuppressor(Suppress.This))
            {
                var result = new Dictionary<Guid, String>()
                {
                    { Guid.Empty, "" }
                };
                foreach (var tag in tags.Rows.Where(x => x.Get<JobDocumentSetTag, JobDocumentSetTagType>(x => x.Type).Equals(type)))
                    result[tag.Get<JobDocumentSetTag, Guid>(c => c.ID)] = tag.Get<JobDocumentSetTag, String>(c => c.Description);

                // row.Height = result.Count > 1
                //     ? new GridLength(1, GridUnitType.Auto)
                //     : new GridLength(0, GridUnitType.Pixel);

                var value = target.SelectedValue;
                target.ItemsSource = result;
                target.SelectedValue = value;
                return result.Count > 1;
            }
        }

        public void Setup()
        {
            _settings = new GlobalConfiguration<JobDocumentSetSettings>().Load();
            tasks.Settings = _settings;
            tasks.Refresh(true, false);

            Folders.Refresh(true, false);
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        public void Refresh()
        {
            LoadDocumentTags();

            Folders.Master = Master;
            Folders.Refresh(false, true);
            
            Documents.Master = Master;
            Documents.Refresh();
            
        }

        private void LoadDocumentTags()
        {
            // Global tags
            var tagFilter = new Filter<JobDocumentSetTag>(x => x.Job.ID).IsEqualTo(Guid.Empty);
            if(Master is not null && Master.ID != Guid.Empty)
            {
                tagFilter = tagFilter.Or(x => x.Job.ID).IsEqualTo(Master.ID);
            }

            var results = Client.QueryMultiple(
                new KeyedQueryDef<JobDocumentSetTag>(
                    tagFilter,
                    new Columns<JobDocumentSetTag>(x => x.ID)
                        .Add(x => x.Type)
                        .Add(x => x.Description),
                    new SortOrder<JobDocumentSetTag>(x => x.Description)
                    ),
                new KeyedQueryDef<JobITP>(
                    new Filter<JobITP>(x => x.Job.ID).IsEqualTo(Master?.ID ?? Guid.Empty),
                    new Columns<JobITP>(x => x.ID).Add(x => x.Code).Add(x => x.Description),
                    new SortOrder<JobITP>(x => x.Code)));

            var tags = results.Get<JobDocumentSetTag>();
            /* Documents.DisciplineVisible = */
            GetTags(tags, JobDocumentSetTagType.Discipline, Discipline); //, DisciplineRow);
            /* Documents.TypeVisible = */
            GetTags(tags, JobDocumentSetTagType.Type, Type); //, TypeRow);
            /* Documents.CategoryVisible = */
            GetTags(tags, JobDocumentSetTagType.Category, Category); //, CategoryRow);
            /* Documents.AreaVisible = */
            GetAreas(results.Get<JobITP>(), Area); //, AreaRow);
        }

        public bool IsReady { get; set; }

        public void CreateToolbarButtons(IPanelHost host)
        {
            host.CreateSetupAction(new PanelAction() { Caption = "Job Settings", Image = PRSDesktop.Resources.specifications, OnExecute = JobSettingsClick });
        }

        private void JobSettingsClick(PanelAction obj)
        {
            if (DynamicGridUtils.EditObject(_settings))
                new GlobalConfiguration<JobDocumentSetSettings>().Save(_settings);
        }

        public Dictionary<string, object[]> Selected()
        {
            return new Dictionary<string, object[]>();
        }

        public void Heartbeat(TimeSpan time)
        {
        }

        private Guid _folderid = Guid.Empty;

        private void Folders_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
        {
            if (e.Rows is null || e.Rows.Length == 0) return;

            _folderid = e.Rows[0].Get<JobDocumentSetFolder, Guid>(x => x.ID);
            LoadDocuments(_folderid);
        }

        private void LoadDocuments(Guid folderID)
        {
            Documents.FolderIDs = Folders.GetChildFolders(folderID).Select(x => x.Get<JobDocumentSetFolder, Guid>(x => x.ID)).ToArray();
            Documents.Refresh();
        }

        private void DynamicSplitPanel_OnOnChanged(object sender, DynamicSplitPanelSettings e)
        {
            LoadDocuments(e.View == DynamicSplitPanelView.Detail ? Guid.Empty : _folderid);
        }

        private void Preview_OnSizeChanged(object sender, SizeChangedEventArgs e)
        {
            //throw new NotImplementedException();
        }

        private void Documents_OnMileStoneSelected(JobDocumentSetMileStoneBlock block)
        {
            tasks.JobID = Master?.ID ?? Guid.Empty;
            tasks.MileStoneID = block?.ID ?? Guid.Empty;
            tasks.Refresh(false, true);
            
            if (block != null && block.Attachments > 0)
            {
                var id = block.ID;
                var files = new Client<JobDocumentSetMileStoneFile>().Query(
                    new Filter<JobDocumentSetMileStoneFile>(x => x.EntityLink.ID).IsEqualTo(block.ID),
                    new Columns<JobDocumentSetMileStoneFile>(x => x.ID)
                        .Add(x => x.DocumentLink.ID)
                        .Add(x => x.DocumentLink.FileName)
                        .Add(x => x.Thumbnail),
                    new SortOrder<JobDocumentSetMileStoneFile>(x => x.DocumentLink.FileName)
                );
                preview.ItemsSource = files.Rows
                    .Select(r =>
                    {
                        var thumbnailData = r.Get<JobDocumentSetMileStoneFile, byte[]?>(c => c.Thumbnail);
                        var image = ImageUtils.LoadImage(thumbnailData);
                        return new Tuple<Guid, String, BitmapImage, JobDocumentSetMileStoneFile>(
                            r.Get<JobDocumentSetMileStoneFile, Guid>(c => c.ID),
                            r.Get<JobDocumentSetMileStoneFile, String>(c => c.DocumentLink.FileName),
                            image != null
                                ? block.Watermark.IsNullOrWhiteSpace()
                                    ? image
                                    : image.AsBitmap().WatermarkImage(block.Watermark, Color.LightSalmon).AsBitmapImage()
                                : ImageUtils.BitmapFromColor(Color.White, 256, 192, Color.Transparent)
                                    .WatermarkImage("No Preview\nAvailable", Color.LightGray).AsBitmapImage(),
                            r.ToObject<JobDocumentSetMileStoneFile>());
                    }).ToList();
            }
            else
                preview.ItemsSource = new List<Tuple<Guid, String, BitmapImage, JobDocumentSetMileStoneFile>>();
        }

        private void Tag_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            Documents.DisciplineID = (Guid)(Discipline.SelectedValue ?? Guid.Empty);
            Documents.TypeID = (Guid)(Type.SelectedValue ?? Guid.Empty);
            Documents.CategoryID = (Guid)(Category.SelectedValue ?? Guid.Empty);
            Documents.AreaID = (Guid)(Area.SelectedValue ?? Guid.Empty);
            Documents.Refresh();
        }

        private void PDFDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var image = (sender as ListViewItem).Content as Tuple<Guid, String, BitmapImage, JobDocumentSetMileStoneFile>;
            if (image != null)
            {
                var viewer = new DocumentEditor(new JobDocumentSetMileStoneFile[] { image.Item4 });
                viewer.ButtonsVisible = false;
                viewer.ShowDialog();
            }
        }

        private void Search_OnKeyUp(object sender, KeyEventArgs e)
        {
            if ((e.Key == Key.Enter) || (e.Key == Key.Return) || (e.Key == Key.Tab) || (e.Key == Key.OemBackTab))
            {
                Documents.SearchText = Search.Text;
                Documents.Refresh();
            }
        }

        private void EditDocumentTags(JobDocumentSetTagType tagtype)
        {
            var editor = new JobDocumentSetTagEditor()
            {
                TagType = tagtype,
                JobID = Master?.ID ?? Guid.Empty
            };
            editor.Refresh(true, true);
            var window = new DynamicContentDialog(editor, false);
            window.Title = $"{tagtype} Document Tags";
            window.ShowDialog();
            LoadDocumentTags();
        }

        private void DisciplineButton_OnClick(object sender, RoutedEventArgs e)
        {
            EditDocumentTags(JobDocumentSetTagType.Discipline);
        }

        private void TypeButton_OnClick(object sender, RoutedEventArgs e)
        {
            EditDocumentTags(JobDocumentSetTagType.Type);
        }

        private void CategoryButton_OnClick(object sender, RoutedEventArgs e)
        {
            EditDocumentTags(JobDocumentSetTagType.Category);
        }

        private void ShowPreview_OnClick(object sender, RoutedEventArgs e)
        {
            PreviewColumn.Width = new GridLength(260, GridUnitType.Pixel);
            ShowPreview.Visibility = Visibility.Collapsed;
        }

        private void HidePreview_OnClick(object sender, RoutedEventArgs e)
        {
            PreviewColumn.Width = new GridLength(0, GridUnitType.Pixel);
            ShowPreview.Visibility = Visibility.Visible;
        }

        private void Tasks_OnOnChanged(object sender, EventArgs args)
        {
            Documents.Refresh();
        }
    }
}