prs/prs.desktop/Panels/Jobs/Requisitions/JobRequisitionGrid.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using com.healthmarketscience.jackcess;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;
using System.Threading;

namespace PRSDesktop
{
    internal class JobRequisitionGrid : DynamicDataGrid<JobRequisition>, IMasterDetailControl<Job,JobRequisition>
    {
        public Job? Master { get; set; }

        public Filter<JobRequisition> MasterDetailFilter => (Master?.ID ?? Guid.Empty) != Guid.Empty
            ? new Filter<JobRequisition>(x => x.Job.ID).IsEqualTo(Master?.ID ?? Guid.Empty)
            : new Filter<JobRequisition>().None();
        
        private readonly Button _approve;
        private readonly Button _createtask;

        public JobRequisitionGrid()
        {
            HiddenColumns.Add(x => x.ID);
            HiddenColumns.Add(x => x.Job.ID);
            HiddenColumns.Add(x => x.Approved);
            _approve = AddButton("Approve", null, ApproveClick);
            _createtask = AddButton("Create Task", null, CreateTask);
        }
        protected override void DoReconfigure(DynamicGridOptions options)
        {
            base.DoReconfigure(options);
            options.SelectColumns = true;
            options.FilterRows = true;
        }

        private bool ApproveClick(Button button, CoreRow[] rows)
        {
            if (rows == null || !rows.Any())
            {
                MessageBox.Show("Please select a row first!");
                return false;
            }

            var requi = rows[0].ToObject<JobRequisition>();
            
            requi.Approved = requi.Approved.IsEmpty() ? DateTime.Now : DateTime.MinValue;
            UpdateRow<DateTime?>(rows[0], "Approved", requi.Approved.IsEmpty() ? null : requi.Approved, true);
            new Client<JobRequisition>().Save(requi, requi.Approved.IsEmpty() ? "Cleared Approval" : "Marked as Approved");
            UpdateButton(_approve, null, !requi.Approved.IsEmpty() ? "Unapprove" : "Approve");
            
            _createtask.IsEnabled = !requi.Approved.IsEmpty();
            
            return false;
        }

        protected override void SelectItems(CoreRow[] rows)
        {
            base.SelectItems(rows);
            if (rows?.Length == 1)
            {
                _approve.Visibility = Security.IsAllowed<CanApproveJobRequisitions>()
                    ? Visibility.Visible
                    : Visibility.Collapsed;
                UpdateButton(_approve, null, !rows[0].Get<JobRequisition, DateTime>(c => c.Approved).IsEmpty() ? "Unapprove" : "Approve");
                
                _createtask.Visibility = Visibility.Visible;
                _createtask.IsEnabled = !rows[0].Get<JobRequisition, DateTime>(c => c.Approved).IsEmpty();
            }
            else
            {
                _approve.Visibility = Visibility.Collapsed;
                _createtask.Visibility = Visibility.Collapsed;
            }
        }

        private bool CreateTask(System.Windows.Controls.Button btn, CoreRow[] rows)
        {
            if (!rows.Any())
            {
                MessageBox.Show("Please select at least one row to add to Task!");
                return false;
            }
            Progress.Show("Working");
            JobRequisition jobrequi = rows.FirstOrDefault().ToObject<JobRequisition>();
            Kanban kanban = new Kanban();
            kanban.ManagerLink.ID = Guid.Parse(new Client<Employee>().Query(
                new Filter<Employee>(x => x.UserLink.UserID).IsEqualTo(ClientFactory.UserID),
                Columns.None<Employee>().Add(x => x.ID)).Rows.FirstOrDefault().Values[0].ToString());
            string? jobnumber = new Client<Job>()
                .Query(
                    new Filter<Job>(x => x.ID).IsEqualTo(Master?.ID ?? Guid.Empty),
                    Columns.None<Job>().Add(x => x.JobNumber)
                ).Rows.FirstOrDefault()?.Get<Job, String>(x => x.JobNumber);
            kanban.JobLink.ID = Master?.ID ?? Guid.Empty;
            kanban.JobLink.Synchronise(Master ?? new Job());
            kanban.Title = $"New Job Requisition Raised for Ordering (Job {jobnumber} ({jobrequi.Number}))";
            kanban.Status = KanbanStatus.Open;
            kanban.Description = $"Requisition number: {jobnumber} ({jobrequi.Number}):{System.Environment.NewLine}";
            CoreTable table = new Client<JobRequisitionItem>().Query
                (
                    new Filter<JobRequisitionItem>(x => x.Requisition.ID).IsEqualTo(jobrequi.ID),
                    Columns.None<JobRequisitionItem>().Add(x => x.ID)
                    );
            if (table.Rows.Any())
            {
                kanban.Description = kanban.Description + "Requisition contains " + table.Rows.Count + " items.";
            }
            Progress.Close();
            var page = new TaskGrid();
            page.OnAfterSave += (form, items) =>
            {
                KanbanAfterSave(form, items.Cast<Kanban>().ToArray());
            };
            return page.EditItems(new[] { kanban });
        }

        private void KanbanAfterSave(IDynamicEditorForm form, Kanban[] items)
        {
            Progress.Show("Saving documents");
            var jobrequi = SelectedRows.FirstOrDefault().ToObject<JobRequisition>();
            var table = Client.Query(
                new Filter<JobRequisitionDocument>(x => x.EntityLink.ID).IsEqualTo(jobrequi.ID),
                Columns.None<JobRequisitionDocument>().Add(x => x.DocumentLink.ID));
            if (table.Rows.Any())
            {
                var docs = new List<KanbanDocument>();
                foreach (var row in table.Rows)
                {
                    var doc = new KanbanDocument();

                    doc.DocumentLink.ID = row.Get<JobRequisitionDocument, Guid>(x => x.DocumentLink.ID);
                    doc.EntityLink.ID = items[0].ID;

                    docs.Add(doc);
                }
                Client.Save(docs, "Created From Job Requi Screen");
            }
            Progress.Close();
        }
        
        protected override void Reload(
        	Filters<JobRequisition> criteria, Columns<JobRequisition> columns, ref SortOrder<JobRequisition>? sort,
        	CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            criteria.Add(MasterDetailFilter);
            if (!Security.IsAllowed<CanApproveJobRequisitions>())
                criteria.Add(new Filter<JobRequisition>(x => x.Approved).IsNotEqualTo(DateTime.MinValue));
            base.Reload(criteria, columns, ref sort, token, action);
        }
        
        protected override bool CanCreateItems()
        {
            return (Master?.ID ?? Guid.Empty) != Guid.Empty;
        }

        public override JobRequisition CreateItem()
        {
            var result = base.CreateItem();
            result.Job.ID = Master?.ID ?? Guid.Empty;
            result.Job.Synchronise(Master ?? new Job());
            return result;
        }
    }
}