prs/prs.desktop/Panels/Employees/EmployeePanel.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;

namespace PRSDesktop;


public class EmployeePanelSettings : IUserConfigurationSettings
{
    public DynamicSplitPanelView View { get; set; }
    public double AnchorWidth { get; set; }
    
    public double RoleHeight { get; set; }
    public double RosterHeight { get; set; }

    public EmployeePanelSettings()
    {
        View = DynamicSplitPanelView.Combined;
        AnchorWidth = 250;
        RoleHeight = 250;
        RosterHeight = 400;
    }
}

/// <summary>
///     Interaction logic for EmployeePanel.xaml
/// </summary>
public partial class EmployeePanel : UserControl, IPanel<Employee>
{

    private enum Suppress
    {
        Events
    }

    private EmployeePanelSettings _settings;

    private void DoLoadSettings()
    {
        using (new EventSuppressor(Suppress.Events))
        {
            _settings = new UserConfiguration<EmployeePanelSettings>().Load();

            SplitPanel.View = _settings.View;
            SplitPanel.AnchorWidth = _settings.AnchorWidth;
            RoleGridRow.Height = new GridLength(_settings.RoleHeight, GridUnitType.Pixel);
            RosterGridRow.Height = new GridLength(_settings.RosterHeight, GridUnitType.Pixel);
         }
    }
    
    private void DoSaveSettings()
    {
        _settings.View = SplitPanel.View;
        _settings.AnchorWidth = SplitPanel.AnchorWidth;
        _settings.RoleHeight = RoleGridRow.Height.Value;
        _settings.RosterHeight = RosterGridRow.Height.Value;
        new UserConfiguration<EmployeePanelSettings>().Save(_settings);
    }
    
    public EmployeePanel()
    {
        using (new EventSuppressor(Suppress.Events))
            InitializeComponent();
    }

    public bool IsReady { get; set; }


    public event DataModelUpdateEvent? OnUpdateDataModel;

    public Dictionary<string, object[]> Selected()
    {
        return new Dictionary<string, object[]> { { typeof(Employee).EntityName(), Employees.SelectedRows } };
    }

    public void Setup()
    {
        using (new EventSuppressor(Suppress.Events))
        {
            DoLoadSettings();

            Employees.HiddenColumns.Add(x => x.RosterTemplate.ID);
            Employees.HiddenColumns.Add(x => x.RosterStart);

            Employees.Refresh(true, false);
            Rosters.Refresh(true, false);
            Teams.Refresh(true, false);
            Roles.Refresh(true, false);
            Activities.Refresh(true, false);
            Forms.Refresh(true, false);
            Qualifications.Refresh(true, false);
            Spreadsheets.Refresh(true, false);
            Jobs.Refresh(true, false);

            RoleCrossTab.Visibility = Security.CanView<Employee>()
                && Security.CanView<Role>()
                && Security.CanView<EmployeeRole>() ? Visibility.Visible : Visibility.Collapsed;
            var visibleTabItems = Tab.Items.OfType<DynamicTabItem>().Where(x => x.Visibility == Visibility.Visible).ToList();
            if(visibleTabItems.Count <= 1)
            {
                foreach(var tab in visibleTabItems)
                {
                    tab.Visibility = Visibility.Collapsed;
                    Tab.SelectedItem = tab;
                }
            }
        }
    }

    public void Shutdown(CancelEventArgs? cancel)
    {
    }

    public void CreateToolbarButtons(IPanelHost host)
    {
        HumanResourcesSetupActions.SecurityGroups(host);
        host.CreateSetupSeparator();
        HumanResourcesSetupActions.EmployeeGroups(host);
        HumanResourcesSetupActions.EmployeePositions(host);
        HumanResourcesSetupActions.EmployeeRoles(host);
        HumanResourcesSetupActions.EmployeeTeams(host);
        HumanResourcesSetupActions.EmployeeActivities(host);
        HumanResourcesSetupActions.EmployeeQualifications(host);
        HumanResourcesSetupActions.EmployeeRosters(host);
        host.CreateSetupSeparator();
        HumanResourcesSetupActions.EmployeeOvertimeRules(host);
        HumanResourcesSetupActions.EmployeeOvertime(host);
        HumanResourcesSetupActions.EmployeeStandardLeave(host);
        host.CreateSetupSeparator();
        HumanResourcesSetupActions.EmployeeSpreadsheetTemplates(host);
    }

    private bool _loaded = false;

    private void Tab_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (sender != Tab || !_loaded) return;
        RefreshCurrentTab();
    }

    private void RefreshCurrentTab()
    {
        if (Tab.SelectedTab == EmployeeTab)
        {
            RefreshEmployeeTab();
        }
        else if (Tab.SelectedTab == RoleCrossTab)
        {
            RefreshRoleTab();
        }
    }

    private void RefreshRoleTab()
    {
        EmployeeRoles.Refresh(true, true);
    }

    private void RefreshEmployeeTab()
    {
        Employees.Refresh(false, true);
        Rosters.Refresh(false, true);
        Teams.Refresh(false, true);
        Roles.Refresh(false, true);
        Activities.Refresh(false, true);
        Forms.Refresh(false, true);
        Qualifications.Refresh(false, true);
        Spreadsheets.Refresh(false, true);
        Jobs.Refresh(false, true);
    }

    public void Refresh()
    {
        RefreshCurrentTab();
        _loaded = true;
    }

    public string SectionName => "Employees";

    public DataModel DataModel(Selection selection)
    {
        var ids = Employees.ExtractValues(x => x.ID, selection).ToArray();
        return new AutoDataModel<Employee>(Filter<Employee>.Where(x => x.ID).InList(ids));
    }

    public void Heartbeat(TimeSpan time)
    {
    }

    private void Employees_OnOnSelectItem(object sender, DynamicGridSelectionEventArgs e)
    {
        var employee = e.Rows?.FirstOrDefault()?.ToObject<Employee>() ?? new Employee();

        Rosters.Load(employee, null);
        //Rosters.Refresh(false, true);

        Teams.EmployeeID = employee.ID;
        Teams.Refresh(false, true);

        //LoadEmployeeThumbnail(employee.Thumbnail.ID);
        
        Roles.EmployeeID = employee.ID;
        Roles.Refresh(false, true);

        Activities.Left = employee;
        Activities.Refresh(false,true);

        Forms.Left = employee;
        Forms.Refresh(false, true);
        
        Qualifications.Load(employee, null);

        Spreadsheets.Master = employee;
        Spreadsheets.Refresh(false,true);

        Jobs.Left = employee;
        Jobs.Refresh(false, true);
    }

    // private void LoadEmployeeThumbnail(Guid imageid)
    // {
    //     Thumbnail.Source = null;
    //     if (imageid == Guid.Empty)
    //         return;
    //     Bitmap result = null;
    //     new Client<Document>().Query(
    //         Filter<Document>.Where(x => x.ID).IsEqualTo(imageid),
    //         new Columns<Document>(x => x.ID, x => x.Data),
    //         null,
    //         (o, e) => Dispatcher.Invoke(() =>
    //         {
    //             if (o?.Rows.Any() == true)
    //             {
    //                 var ms = new MemoryStream(o.Rows.First().Get<Document, byte[]>(x => x.Data));
    //                 Thumbnail.Source = new Bitmap(ms).AsBitmapImage();
    //             }
    //         })
    //     );
    // }

    private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    {
        if (EventSuppressor.IsSet(Suppress.Events))
            return;
        DoSaveSettings();
    }
    
    private void Roles_OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (EventSuppressor.IsSet(Suppress.Events))
            return;
        DoSaveSettings();
    }
    
    private void Roles_OnOnChanged(object sender, EventArgs args)
    {
        Activities.Refresh(false,true);
        Forms.Refresh(false, true);
    }


    private void Rosters_OnOnChanged(object sender, EventArgs args)
    {
        //Employees.Refresh(false, true);
    }

    private void Rosters_OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (EventSuppressor.IsSet(Suppress.Events))
            return;
        DoSaveSettings();
    }

    private void Rosters_EmployeeChanged()
    {
        Employees.Refresh(false, true);
    }
}