prs/prs.desktop/Setups/SystemSetupActions.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Comal.Classes;
using Comal.Classes.SecurityDescriptors;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Wpf;
using PRSDesktop.Integations.V6;
using PRSDesktop.Integrations.Logikal;

namespace PRSDesktop;


public static class SystemSetupActions
{


    private class V6SettingsGrid : DynamicItemsListGrid<V6Settings>
    {

        private void Validate<T>(string sql, List<string> errors) where T : V6Object, new()
        {
            var t = new T();
            List<string> _e = new();
            t.ValidateQuery(sql.Replace('\n', ' '), _e);
            if (_e.Any())
            {
                errors.Add($"The query for {typeof(T).Name} has some errors:");
                errors.AddRange(_e);
            }
        }
        
        private static void ValidateUom(V6Settings settings, string uomcode, List<string> errors, IEnumerable<ProductDimensionUnit> uoms, params string[] checks)
        {
            var _uomvalue = CoreUtils.GetPropertyValue(settings, uomcode) as string;
            if (string.IsNullOrWhiteSpace(_uomvalue))
            {
                errors.Add($"{uomcode.SplitCamelCase()} may not be blank!");
                return;
            }

            var _uom = uoms.FirstOrDefault(x => string.Equals(x.Code, _uomvalue));
            if (_uom == null)
            {
                errors.Add($"{uomcode.SplitCamelCase()}: {_uomvalue} is not a value Unit of Measure!");
                return;
            }

            List<string> _missing = new();
            foreach (var _check in checks)
            {
                var _enabled = (bool)(CoreUtils.GetPropertyValue(_uom, _check) ?? false);
                if (!_enabled)
                    _missing.Add(_check);
            }
            if (_missing.Any())
                errors.Add($"{_uomvalue} is missing the following checks: {string.Join(", ",_missing)}");
                
        }
        
        protected override void DoValidate(V6Settings[] items, List<string> errors)
        {
            base.DoValidate(items, errors);

            var _item = items.FirstOrDefault();
            if (_item == null)
                return;
            
            var _uoms = Client.Query(new Filter<ProductDimensionUnit>().All(), Columns.All<ProductDimensionUnit>()).ToObjects<ProductDimensionUnit>().ToArray();
            if (_item.ImportCosts != V6ImportCosts.None)
            {
                ValidateUom(_item, nameof(V6Settings.ProfileUom), errors, _uoms, nameof(ProductDimensionUnit.HasLength));
                ValidateUom(_item, nameof(V6Settings.ComponentUom), errors, _uoms, nameof(ProductDimensionUnit.HasQuantity));
                ValidateUom(_item, nameof(V6Settings.GlassUom), errors, _uoms, nameof(ProductDimensionUnit.HasHeight), nameof(ProductDimensionUnit.HasWidth));
            }

            if (_item.ImportDesigns == V6ImportDesigns.ToManufacturing)
            {
                if (String.IsNullOrWhiteSpace(_item.PacketTemplate))
                    errors.Add("Packet Template my not be blank!");
                else
                {
                    var _found = Client
                        .Query(new Filter<ManufacturingTemplate>(x => x.Code).IsEqualTo(_item.PacketTemplate),
                            Columns.None<ManufacturingTemplate>()).Rows.Any();
                    if (!_found)
                        errors.Add($"Packet Template [{_item.PacketTemplate}] does not exist!");
                }
            }

            _item.CheckSQL();
            Validate<V6Quote>(_item.QuoteSQL, errors);
            Validate<V6Elevation>(_item.ElevationSQL, errors);
            Validate<V6Drawings>(_item.DrawingsSQL, errors);
            Validate<V6Profile>(_item.ProfileSQL, errors);
            Validate<V6Component>(_item.ComponentSQL, errors);
            Validate<V6Labour>(_item.LabourSQL, errors);
            Validate<V6Glass>(_item.GlassSQL, errors);
        }


    }

    private class LogikalSettingsGrid : DynamicItemsListGrid<LogikalSettings>
    {

        private void ValidateSQL<T>(string sql, List<string> errors) where T : LogikalItem, new()
        {
            var t = new T();
            List<string> _e = new();
            t.ValidateQuery(sql, _e);
            if (_e.Any())
            {
                errors.Add($"The query for {typeof(T).Name} has some errors:");
                errors.AddRange(_e);
            }
        }

        private static void ValidateStatus(string status,List<String> errors)
        {
            if (string.IsNullOrWhiteSpace(status))
                errors.Add("Job Status may not be blank");
            else
            {
                var _statuses = Client.Query(new Filter<JobStatus>(x=>x.Code).IsEqualTo(status), Columns.None<JobStatus>().Add(x=>x.ID));
                if (!_statuses.Rows.Any())
                    errors.Add($"[{status}] is not a valid Job Status!");
            }
        }


        private static void ValidateTaxCode(string taxcode, List<String> errors)
        {
            if (string.IsNullOrWhiteSpace(taxcode))
                errors.Add("Tax Code may not be blank");
            else
            {
                var _taxcodes = Client.Query(new Filter<TaxCode>(x => x.Code).IsEqualTo(taxcode), Columns.None<TaxCode>().Add(x => x.ID));
                if (!_taxcodes.Rows.Any())
                    errors.Add($"[{taxcode}] is not a valid Tax Code!");
            }
        }

        private static void ValidateUom(LogikalSettings settings, string uomcode, List<string> errors, IEnumerable<ProductDimensionUnit> uoms, params string[] checks)
        {
            var _uomvalue = CoreUtils.GetPropertyValue(settings, uomcode) as string;
            if (string.IsNullOrWhiteSpace(_uomvalue))
            {
                errors.Add($"{uomcode.SplitCamelCase()} may not be blank!");
                return;
            }

            var _uom = uoms.FirstOrDefault(x => string.Equals(x.Code, _uomvalue));
            if (_uom == null)
            {
                errors.Add($"{uomcode.SplitCamelCase()}: {_uomvalue} is not a value Unit of Measure!");
                return;
            }

            List<string> _missing = new();
            foreach (var _check in checks)
            {
                var _enabled = (bool)(CoreUtils.GetPropertyValue(_uom, _check) ?? false);
                if (!_enabled)
                    _missing.Add(_check);
            }
            if (_missing.Any())
                errors.Add($"{_uomvalue} is missing the following checks: {string.Join(", ", _missing)}");

        }

        protected override void DoValidate(LogikalSettings[] items, List<string> errors)
        {
            base.DoValidate(items, errors);

            var _item = items.FirstOrDefault();
            if (_item == null)
                return;

            ValidateStatus(_item.JobStatus, errors);

            ValidateTaxCode(_item.TaxCode, errors);

            var _uoms = Client.Query(new Filter<ProductDimensionUnit>().All(), Columns.All<ProductDimensionUnit>()).ToObjects<ProductDimensionUnit>().ToArray();
            ValidateUom(_item, nameof(LogikalSettings.ProfileUom), errors, _uoms, nameof(ProductDimensionUnit.HasLength));
            ValidateUom(_item, nameof(LogikalSettings.ComponentUom), errors, _uoms, nameof(ProductDimensionUnit.HasQuantity));
            ValidateUom(_item, nameof(LogikalSettings.GlassUom), errors, _uoms, nameof(ProductDimensionUnit.HasHeight), nameof(ProductDimensionUnit.HasWidth));


            //if (_item.ImportDesigns == V6ImportDesigns.ToManufacturing)
            //{
            //    if (String.IsNullOrWhiteSpace(_item.PacketTemplate))
            //        errors.Add("Packet Template my not be blank!");
            //    else
            //    {
            //        var _found = Client
            //            .Query(new Filter<ManufacturingTemplate>(x => x.Code).IsEqualTo(_item.PacketTemplate),
            //                Columns.None<ManufacturingTemplate>()).Rows.Any();
            //        if (!_found)
            //            errors.Add($"Packet Template [{_item.PacketTemplate}] does not exist!");
            //    }
            //}

            _item.CheckSQL();
            ValidateSQL<LogikalProfile>(_item.BillOfMaterialsProfileSQL, errors);
            ValidateSQL<LogikalComponent>(_item.BillOfMaterialsComponentSQL, errors);
            ValidateSQL<LogikalGlass>(_item.BillOfMaterialsGlassSQL, errors);
            ValidateSQL<LogikalProfile>(_item.ElevationProfileSQL, errors);
            ValidateSQL<LogikalComponent>(_item.ElevationComponentSQL, errors);
            ValidateSQL<LogikalGlass>(_item.ElevationGlassSQL, errors);
            ValidateSQL<LogikalLabour>(_item.LabourSQL, errors);
            ValidateSQL<LogikalFinish>(_item.FinishSQL, errors);

        }

    }


    public static void ERPStatuses(IPanelHost host)
    {
        host.CreateSetupActionIf(
            "Logikal Settings", 
            PRSDesktop.Resources.logikal, 
            (action) =>
            {
                var _logikalSettings = new GlobalConfiguration<LogikalSettings>().Load();
                _logikalSettings.CheckSQL();
                var _logikalSettingsGrid = new LogikalSettingsGrid();
                if (_logikalSettingsGrid.EditItems(new LogikalSettings[] { _logikalSettings }))
                    new GlobalConfiguration<LogikalSettings>().Save(_logikalSettings);
            },
            Security.IsAllowed<EditLogikalSettings>()
        );
        
        host.CreateSetupActionIf(
            "V6 Settings", 
            PRSDesktop.Resources.v6, 
            (action) =>
            {
                var _v6Settings = new GlobalConfiguration<V6Settings>().Load();
                _v6Settings.CheckSQL();
                var grid = new V6SettingsGrid();
                if (grid.EditItems(new V6Settings[] { _v6Settings }))
                    new GlobalConfiguration<V6Settings>().Save(_v6Settings);
            },
            Security.IsAllowed<EditV6Settings>()
        );
    }
}