prs/prs.desktop/Panels/Jobs/ProjectsPanel_Old.xaml.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.DynamicGrid.Spreadsheet;
using InABox.WPF;
using Microsoft.Office.Interop.Outlook;
using System.ComponentModel;
using Selection = InABox.Core.Selection;
using PRSDesktop.Panels.Jobs;

namespace PRSDesktop;

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

}


/// <summary>
///     Interaction logic for JobPanel.xaml
/// </summary>
public partial class ProjectsPanel_Old : UserControl, IPanel<Job>
{
    private JobPanelSettings _settings;
    
    private int CurrentPage = -1;
    
    private readonly List<IMasterDetailPage<Job>> Pages;
    
    private DateTime lastselection = DateTime.MaxValue;
   
    private IDataModelSource modelsource;

    // User Settings
    private JobScreenSettings settings;
    
    private DispatcherTimer timer;
    
    protected void CreatePage<T>(String caption) where T : class, IMasterDetailPage<Job>
    {
        var header = new DynamicTabItem() { Header = caption };
        JobPages.Items.Add(header);
        if (Activator.CreateInstance(typeof(T), header) is T page)
            Pages.Add(page);
    }
    
    public ProjectsPanel_Old()
    {
        InitializeComponent();

        Pages = new List<IMasterDetailPage<Job>>();
        
        CreatePage<JobDetailPanel<JobDetails>>("Details");
        CreatePage<JobDetailPanel<JobScopePanel>>("Scopes");
        CreatePage<JobDetailPanel<JobDocumentSetPanel>>("Documents");
        CreatePage<JobDetailPanel<JobStagesPanel>>("Stages");
        CreatePage<JobDetailGrid<JobITPGrid, JobITP>>("ITPs");
        CreatePage<JobDetailGrid<JobProductMappingsGrid, JobProductMapping>>("Product Mappings");
        CreatePage<JobDetailGrid<JobProductStylesGrid, JobStyle>>("Product Styles");
        CreatePage<JobDetailPanel<JobBillOfMaterialsPanel>>("BOM");
        CreatePage<JobDetailPanel<JobRequisitionPanel>>("Requisitions");
        CreatePage<JobDetailGrid<JobOrderGrid, PurchaseOrderItem>>("Orders");
        CreatePage<JobDetailPanel<JobDesignPanel>>("Designs");
        CreatePage<JobDetailGrid<ManufacturingGrid, ManufacturingPacket>>("Manufacturing");
        CreatePage<JobDetailGrid<ReadyToGoGrid, DeliveryItem>>("Dispatch");
        CreatePage<JobDetailPanel<DeliveryPanel>>("Deliveries");
        CreatePage<JobDetailGrid<DeliveredOnSiteGrid, DeliveryItem>>("OnSite");
        CreatePage<JobDetailPanel<TaskPanel>>("Tasks");
        CreatePage<JobDetailGrid<JobEquipmentGrid, JobEquipment>>("EquipmentTab");
        CreatePage<JobDetailPanel<JobEmployeePanel>>("Employees");
        CreatePage<JobDetailGrid<JobTrackerGrid, JobTracker>>("Trackers");
        CreatePage<JobDetailPanel<JobAssignmentPanel>>("Assignments");
        CreatePage<JobDetailGrid<JobTimesheetGrid, TimeSheet>>("Timesheets");
        CreatePage<JobDetailGrid<JobFormGrid, JobForm>>("Forms");
        CreatePage<JobDetailPanel<InvoicePanel>>("Invoices");
        CreatePage<JobDetailGrid<JobSpreadsheetGrid, JobSpreadsheet>>("Spreadsheets");
        CreatePage<JobDetailPanel<JobSummaryPanel>>("Summary");
    }

    private IMasterDetailPage<Job>? SelectedPage => Pages.FirstOrDefault(x => x.Tab == JobPages.SelectedTab);

    public bool IsReady { get; set; }

    public Dictionary<string, object[]> Selected()
    {
        return SelectedPage?.Selected()
            ?? new Dictionary<string, object[]> { { typeof(Job).EntityName(), JobGrid.SelectedRows } };
    }

    public void Setup()
    {

                settings = new UserConfiguration<JobScreenSettings>().Load();

        
        SplitPanel.View = settings.ViewType == ScreenViewType.Register ? DynamicSplitPanelView.Master :
            settings.ViewType == ScreenViewType.Details ? DynamicSplitPanelView.Detail : DynamicSplitPanelView.Combined;
        SplitPanel.AnchorWidth = Math.Max(20,settings.AnchorWidth);

        JobGrid.OnSelectItem += JobGrid_OnSelectItem;
        JobGrid.BeforeRefresh += JobGrid_BeforeRefresh;
        JobGrid.AfterRefresh += JobGrid_AfterRefresh;

        Scopes.Visibility = Security.CanView<JobScope>() ? Visibility.Visible : Visibility.Collapsed;
        Documents.Visibility = Security.CanView<JobDocumentSet>() ? Visibility.Visible : Visibility.Collapsed;
        Stages.Visibility = ClientFactory.IsSupported<JobStage>() ? Visibility.Visible : Visibility.Collapsed;
        ITPs.Visibility = ClientFactory.IsSupported<JobITP>() ? Visibility.Visible : Visibility.Collapsed;
        ProductMappings.Visibility = ClientFactory.IsSupported<JobProductMapping>() ? Visibility.Visible : Visibility.Collapsed;
        ProductStyles.Visibility = ClientFactory.IsSupported<JobStyle>() ? Visibility.Visible : Visibility.Collapsed;
        BOM.Visibility = ClientFactory.IsSupported<JobBillOfMaterials>() ? Visibility.Visible : Visibility.Collapsed;
        Requisitions.Visibility = ClientFactory.IsSupported<JobRequisition>() ? Visibility.Visible : Visibility.Collapsed;
        Orders.Visibility = ClientFactory.IsSupported<PurchaseOrderItem>() ? Visibility.Visible : Visibility.Collapsed;
        Setouts.Visibility = ClientFactory.IsSupported<Setout>() ? Visibility.Visible : Visibility.Collapsed;
        Manufacturing.Visibility = ClientFactory.IsSupported<ManufacturingPacket>() ? Visibility.Visible : Visibility.Collapsed;
        Dispatch.Visibility = ClientFactory.IsSupported<DeliveryItem>() ? Visibility.Visible : Visibility.Collapsed;
        Deliveries.Visibility = ClientFactory.IsSupported<Delivery>() ? Visibility.Visible : Visibility.Collapsed;
        OnSite.Visibility = ClientFactory.IsSupported<DeliveryItem>() ? Visibility.Visible : Visibility.Collapsed;
        Tasks.Visibility = ClientFactory.IsSupported<Kanban>() ? Visibility.Visible : Visibility.Collapsed;
        EquipmentTab.Visibility = ClientFactory.IsSupported<Equipment>() ? Visibility.Visible : Visibility.Collapsed;
        Employees.Visibility = ClientFactory.IsSupported<Employee>() ? Visibility.Visible : Visibility.Collapsed;
        Trackers.Visibility = ClientFactory.IsSupported<GPSTracker>() ? Visibility.Visible : Visibility.Collapsed;
        Assignments.Visibility = ClientFactory.IsSupported<Assignment>() ? Visibility.Visible : Visibility.Collapsed;
        Timesheets.Visibility = ClientFactory.IsSupported<TimeSheet>() ? Visibility.Visible : Visibility.Collapsed;
        Forms.Visibility = Security.CanView<JobForm>() ? Visibility.Visible : Visibility.Collapsed;
        Invoices.Visibility = Security.CanView<Invoice>() ? Visibility.Visible : Visibility.Collapsed;
        Spreadsheets.Visibility = Security.CanView<JobSpreadsheet>() ? Visibility.Visible : Visibility.Collapsed;
        Summary.Visibility = ClientFactory.IsSupported<JobMaterial>() ? Visibility.Visible : Visibility.Collapsed;

        JobGrid.ColumnsTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
        JobGrid.Refresh(true, false);

        timer = new DispatcherTimer();
        timer.Tick += Timer_Tick;
        timer.Interval = new TimeSpan(0, 0, 0, 0, 100);
        timer.IsEnabled = true;
    }

    private bool _jobGridRefreshing;

    private void JobGrid_BeforeRefresh(object sender, BeforeRefreshEventArgs args)
    {
        _jobGridRefreshing = true;
    }

    private void JobGrid_AfterRefresh(object sender, AfterRefreshEventArgs args)
    {
        if (settings.CurrentJob == Guid.Empty)
        {
            JobGrid.SelectedRows = Array.Empty<CoreRow>();
        }
        else
        {
            JobGrid.SelectedRows = JobGrid.Data.Rows.Where(x => x.Get<Job, Guid>(x => x.ID) == settings.CurrentJob).ToArray();
        }
        _jobGridRefreshing = false;
    }

    public void Shutdown(CancelEventArgs? cancel)
    {
        timer.IsEnabled = false;
        timer = null;

        Details.Content = null;
        Scopes.Content = null;
        Documents.Content = null;
        Stages.Content = null;
        ITPs.Content = null;
        BOM.Content = null;
        Setouts.Content = null;
        Requisitions.Content = null;
        Orders.Content = null;
        Manufacturing.Content = null;
        Dispatch.Content = null;
        Deliveries.Content = null;
        OnSite.Content = null;
        Tasks.Content = null;
        EquipmentTab.Content = null;
        Employees.Content = null;
        Trackers.Content = null;
        Assignments.Content = null;
        Timesheets.Content = null;
        Forms.Content = null;
        Invoices.Content = null;
        Spreadsheets.Content = null;
        Summary.Content = null;
    }

    public void Refresh()
    {
        JobGrid.Refresh(false, true);

        lastselection = DateTime.MinValue;
    }

    public void CreateToolbarButtons(IPanelHost host)
    {
        ProjectSetupActions.JobStatuses(host);
        ProjectSetupActions.DocumentMilestones(host);
        ProjectSetupActions.JobScopeStatuses(host);
        ProjectSetupActions.DrawingTemplates(host);
        host.CreateSetupSeparator();
        ProjectSetupActions.JobSpreadsheetTemplates(host);
        host.CreateSetupSeparator();
        ProjectSetupActions.SetoutGroups(host);

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

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

    public event DataModelUpdateEvent? OnUpdateDataModel;

    public string SectionName => modelsource?.SectionName ?? "Job Details";

    public DataModel DataModel(Selection selection)
    {
        if (modelsource == null)
        {
            var row = JobGrid.SelectedRows.FirstOrDefault();
            var jobid = row != null ? row.Get<Job, Guid>(x => x.ID) : CoreUtils.FullGuid;
            return new JobDetailsDataModel(new Filter<Job>(x => x.ID).IsEqualTo(jobid));
        }

        return modelsource.DataModel(selection);
    }

    public void Heartbeat(TimeSpan time)
    {
    }

    private void Timer_Tick(object? sender, EventArgs e)
    {
        if (lastselection < DateTime.Now.AddMilliseconds(-500) && !_jobGridRefreshing)
        {
            lastselection = DateTime.MaxValue;
            
            var job = JobGrid.SelectedRows.FirstOrDefault()?.ToObject<Job>() ?? new Job();
            var dataModelSource = SelectedPage?.Refresh(job);
            if (JobPages.SelectedIndex != CurrentPage)
            {
                if(dataModelSource is not null)
                {
                    modelsource = dataModelSource;
                    OnUpdateDataModel?.Invoke(dataModelSource.SectionName, dataModelSource.DataModel(Selection.None));
                }
                CurrentPage = JobPages.SelectedIndex;
            }
        }
    }

    private void JobGrid_OnSelectItem(object sender, DynamicGridSelectionEventArgs e)
    {
        if (!_jobGridRefreshing)
        {
            lastselection = DateTime.Now;
            settings.CurrentJob = e.Rows?.FirstOrDefault()?.Get<Job, Guid>(x => x.ID) ?? Guid.Empty;
            new UserConfiguration<JobScreenSettings>().Save(settings);
        }
    }

    private void JobPages_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (e.Source == JobPages)
            lastselection = DateTime.MinValue;
    }

    private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    {
        settings.ViewType = SplitPanel.View == DynamicSplitPanelView.Master ? ScreenViewType.Register :
            SplitPanel.View == DynamicSplitPanelView.Detail ? ScreenViewType.Details : ScreenViewType.Combined;
        settings.AnchorWidth = SplitPanel.AnchorWidth;
        new UserConfiguration<JobScreenSettings>().Save(settings);
        var newTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
        if (JobGrid.ColumnsTag != newTag)
        {
            JobGrid.ColumnsTag = newTag;
            JobGrid.Refresh(true, true);
        }
    }
}