new design for actions: refactored case actions, added action support for collector and wage type

function: new method to get calendar day count
payroll function: added support for the regulation namespace
payrun function: added get/set payrun result
payrun function: added get wage type name/number by number/name
date period extensions: fixed condition in GetWorkingDaysCount()
updated to c# 14
updated database version to 0.9.5
updated version to 0.9.0-beta.13

Author: Jani Giannoudis

Client.Scripting.Tests/PayrollEngine.Client.Scripting.Tests.csproj

@@ -8,7 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageReference Include="xunit" Version="2.9.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
       <PrivateAssets>all</PrivateAssets>

Client.Scripting/ActionPropertyInfo.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace PayrollEngine.Client.Scripting;
+
+/// <summary>
+/// Action property info
+/// </summary>
+public class ActionPropertyInfo
+{
+    /// <summary>The property name</summary>
+    public FunctionType FunctionType { get; init; }
+
+    /// <summary>The property name</summary>
+    public string Name { get; init; }
+
+    /// <summary>The property description</summary>
+    public string Description { get; init; }
+
+    /// <summary>The property type</summary>
+    public Type Type { get; init; }
+
+    /// <summary>Readonly property</summary>
+    public bool ReadOnly { get; init; }
+}

Client.Scripting/ActionReflector.cs

@@ -47,29 +47,25 @@ public static List<ActionInfo> LoadFrom(Assembly assembly)
 
         // setup action cache
         var actions = new List<ActionInfo>();
-        foreach (var type in assembly.GetTypes().Where(x => !x.IsGenericType && !x.IsNested))
-        {
-
-            // action provider attribute
-            var providerAttribute = GetProviderAttribute(type);
-            if (providerAttribute == null)
-            {
-                continue;
-            }
 
-            foreach (var typeMethod in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
+        // each type
+        var types = assembly.GetTypes().Where(x => IsFunctionType(x) && !x.IsGenericType && !x.IsNested);
+        foreach (var type in types)
+        {
+            // each method
+            var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+            foreach (var method in methods)
             {
                 // action attribute
-                var actionAttribute = GetActionAttribute(typeMethod);
+                var actionAttribute = GetActionAttribute(method);
                 if (actionAttribute == null)
                 {
                     continue;
                 }
 
                 // action attribute
-                var actionInfo = new ActionInfo(providerAttribute.Type)
+                var actionInfo = new ActionInfo(type)
                 {
-                    Namespace = providerAttribute.Namespace,
                     Name = GetPropertyValue<string>(actionAttribute,
                         nameof(ActionAttribute.Name)),
                     Description = GetPropertyValue<string>(actionAttribute,
@@ -82,7 +78,7 @@ public static List<ActionInfo> LoadFrom(Assembly assembly)
                 actions.Add(actionInfo);
 
                 // action parameter attributes (optional)
-                var parameterAttributes = GetActionParameterAttributes(typeMethod,
+                var parameterAttributes = GetActionParameterAttributes(method,
                     typeof(ActionParameterAttribute));
                 if (parameterAttributes != null)
                 {
@@ -92,7 +88,7 @@ public static List<ActionInfo> LoadFrom(Assembly assembly)
                             nameof(ActionParameterAttribute.Name));
 
                         // test parameter
-                        if (!typeMethod.GetParameters().Any(x => string.Equals(x.Name, name)))
+                        if (!method.GetParameters().Any(x => string.Equals(x.Name, name)))
                         {
                             throw new PayrollException($"Invalid action parameter {actionInfo.Name}.{name}");
                         }
@@ -131,7 +127,7 @@ public static List<ActionInfo> LoadFrom(Assembly assembly)
                 }
 
                 // action issue attributes (optional)
-                var issuesAttributes = GetActionParameterAttributes(typeMethod, typeof(ActionIssueAttribute));
+                var issuesAttributes = GetActionParameterAttributes(method, typeof(ActionIssueAttribute));
                 if (issuesAttributes != null)
                 {
                     foreach (var issueAttribute in issuesAttributes)
@@ -151,26 +147,25 @@ public static List<ActionInfo> LoadFrom(Assembly assembly)
         }
 
         // order by action name
-        actions.Sort((x, y) => string.CompareOrdinal(x.FullName, y.FullName));
+        actions.Sort((x, y) => string.CompareOrdinal(x.Name, y.Name));
         return actions;
     }
 
     /// <summary>
-    /// Get action provider attribute
+    /// Test for function type
     /// </summary>
-    /// <param name="type">Action member type</param>
-    private static ActionProviderAttribute GetProviderAttribute(MemberInfo type)
+    /// <param name="type">Type to test</param>
+    private static bool IsFunctionType(Type type)
     {
-        var providerAttributeName = typeof(ActionProviderAttribute).FullName;
-        foreach (var typeAttribute in type.GetCustomAttributes())
+        while (type != null)
         {
-            // provider attribute type
-            if (string.Equals(providerAttributeName, typeAttribute.GetType().FullName))
+            if (type == typeof(Function.Function))
             {
-                return typeAttribute as ActionProviderAttribute;
+                return true;
             }
+            type = type.BaseType;
         }
-        return null;
+        return false;
     }
 
     /// <summary>

Client.Scripting/Cache/Cache.cs Client.Scripting/Cache.csClient.Scripting/Cache/Cache.cs renamed to Client.Scripting/Cache.cs

@@ -2,12 +2,12 @@
 //#define CACHE_LOG
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
+using System.Collections.Generic;
 using PayrollEngine.Client.Scripting.Function;
 
-namespace PayrollEngine.Client.Scripting.Cache;
+namespace PayrollEngine.Client.Scripting;
 
 
 /// <summary>Result cache cycle</summary>
@@ -24,13 +24,13 @@ public enum ResultCacheCycle
 public abstract class ConsolidatedResultCacheBase
 {
     /// <summary>The caching start date</summary>
-    public DateTime CycleStartDate { get; }
+    private DateTime CycleStartDate { get; }
 
     /// <summary>The result cache cycle</summary>
-    public ResultCacheCycle CacheCycle { get; }
+    private ResultCacheCycle CacheCycle { get; }
 
     /// <summary>The payrun job status</summary>
-    public PayrunJobStatus? JobStatus { get; }
+    protected PayrunJobStatus? JobStatus { get; }
 
     /// <summary>Cache constructor</summary>
     /// <param name="cycleStartDate">The cycle start date</param>
@@ -81,19 +81,11 @@ protected List<DateTime> GetConsolidatedPeriodStarts(PayrunFunction function, Co
             return null;
         }
 
-        // job status
+        // mismatching job status
         if (query.JobStatus != JobStatus)
         {
-            if (!query.JobStatus.HasValue || !JobStatus.HasValue)
-            {
-                // mismatching job status
-                return null;
-            }
-            // test matching job status by bit mask, duplicated in backend database stored procedure GetConsolidatedXxxResults
-            if ((query.JobStatus.Value & JobStatus.Value) != query.JobStatus.Value)
-            {
-                return null;
-            }
+            function.LogWarning($"Mismatching cache query job status: {query.JobStatus} vs {JobStatus}");
+            return null;
         }
 
         // periods: duplicated in backend domain scripting type PayrunRuntime
@@ -113,7 +105,7 @@ protected List<DateTime> GetConsolidatedPeriodStarts(PayrunFunction function, Co
         }
 
         // order periods from newest to oldest
-        return [..periodStarts.OrderByDescending(x => x)];
+        return [.. periodStarts.OrderByDescending(x => x)];
     }
 
     // Duplicated in backend payroll repository command
@@ -352,7 +344,7 @@ private bool PrepareResultCache(PayrunFunction function, string runtimeKey = nul
                 var cacheStartDate = GetCacheStartDate(function);
                 // initialize cache
                 var query = new WageTypeConsolidatedResultQuery(new List<decimal>(),
-                    cacheStartDate, PayrunJobStatus.Legal);
+                    cacheStartDate, JobStatus);
                 ConsolidatedResults = function.GetConsolidatedWageTypeResults(query);
 
 #if CACHE_LOG

Client.Scripting/CaseObject.cs

@@ -29,8 +29,8 @@ public static string GetNamespace(this MemberInfo member) =>
 
     /// <summary>Get case field name</summary>
     /// <param name="property">Property</param>
-    public static string GetCaseFieldName(this PropertyInfo property) =>
-        GetNamespace(property) + property.Name;
+    public static string GetCaseFieldName(this PropertyInfo property) => 
+        property.GetNamespace() + property.Name;
 }
 
 /// <summary>Case object</summary>