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

using System;
using System.Collections.Generic;
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 NPOI.SS.Formula.Functions;

namespace PRSDesktop
{
    internal class JobRequisitionGrid : DynamicDataGrid<JobRequisition>, IJobControl
    {
        public Job Job { get; set; }
        
        public JobPanelSettings Settings { get; set; }

        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(FluentList<DynamicGridOption> options)
        {
            base.DoReconfigure(options);
            options.AddRange(
                DynamicGridOption.SelectColumns,
                DynamicGridOption.FilterRows
                );
        }

        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), new Columns<Employee>(x => x.ID)).Rows.FirstOrDefault().Values[0].ToString());
            string jobnumber = new Client<Job>().Query(new Filter<Job>(x => x.ID).IsEqualTo(Job.ID), new Columns<Job>(x => x.JobNumber)).Rows.FirstOrDefault().Values[0].ToString();
            kanban.JobLink.ID = Job.ID;
            kanban.JobLink.Synchronise(Job);
            kanban.Title = "New Job Requisition Raised for Ordering (Job " + jobnumber + " (" + jobrequi.Number + ")" + ")";
            kanban.Category = "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),
                    new Columns<JobRequisitionItem>(x => x.ID)
                    );
            if (table.Rows.Any())
            {
                kanban.Description = kanban.Description + "Requisition contains " + table.Rows.Count + " items.";
            }
            Progress.Close();
            var page = new TaskGrid();
            page.MyID = App.EmployeeID;
            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");
            JobRequisition jobrequi = SelectedRows.FirstOrDefault().ToObject<JobRequisition>();
            CoreTable table = new Client<JobRequisitionDocument>().Query(new Filter<JobRequisitionDocument>(x => x.EntityLink.ID).IsEqualTo(jobrequi.ID),
                new Columns<JobRequisitionDocument>(x => x.DocumentLink.ID, x => x.DocumentLink.FileName));
            if (table.Rows.Any())
            {
                List<KanbanDocument> docs = new List<KanbanDocument>();
                foreach (CoreRow row in table.Rows)
                {
                    KanbanDocument doc = new KanbanDocument();
                    doc.DocumentLink.ID = Guid.Parse(row.Values[0].ToString());
                    if (row.Values[1] != null)
                        doc.DocumentLink.FileName = row.Values[1].ToString();
                    doc.EntityLink.ID = items[0].ID;
                    docs.Add(doc);
                }
                new Client<KanbanDocument>().Save(docs, "Created From Job Requi Screen");
            }
            Progress.Close();
        }
        
        protected override void Reload(Filters<JobRequisition> criteria, Columns<JobRequisition> columns, ref SortOrder<JobRequisition>? sort,
            Action<CoreTable?, Exception?> action)
        {
            if (!Security.IsAllowed<CanApproveJobRequisitions>())
                criteria.Add(new Filter<JobRequisition>(x => x.Approved).IsNotEqualTo(DateTime.MinValue));

            criteria.Add(new Filter<JobRequisition>(x => x.Job.ID).IsEqualTo(Job.ID));

            base.Reload(criteria, columns, ref sort, action);
        }
        
        protected override bool CanCreateItems()
        {
            return Job.ID != Guid.Empty;
        }

        protected override JobRequisition CreateItem()
        {
            var result = base.CreateItem();
            result.Job.ID = Job.ID;
            result.Job.Synchronise(Job);
            return result;
        }
    }
}