case set: added change reason and forecast

report: added user type
payroll service get derived reports: added support for user type
command manager: fixed working path with keep-path option
exchange import: improved handling of text and binary content
updated version to 0.9.0-beta.4

Author: Jani Giannoudis

Client.Core/Command/CommandBase.cs

@@ -61,18 +61,18 @@ protected void ProcessError(ICommandConsole console, Exception exception)
         {
             return;
         }
+        var message = exception.GetBaseException().Message;
 
         // api error
         var apiError = exception.GetApiErrorMessage();
         if (!string.IsNullOrWhiteSpace(apiError))
         {
+            message = apiError;
             console.DisplayErrorLine(apiError);
         }
-        else
-        {
-            // generic error log
-            Log.Error(exception, exception.GetBaseException().Message);
-        }
+
+        // log
+        Log.Error(exception, message);
     }
 
     /// <summary>

Client.Core/Command/CommandLineParser.cs

@@ -1,38 +1,38 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
 namespace PayrollEngine.Client.Command;
 
 /// <summary>Represents the environment command line arguments</summary>
-public class CommandLineParser(string[] commandLineArgs)
+public class CommandLineParser(string[] arguments)
 {
-    private string[] CommandLineArgs { get; } = commandLineArgs ?? throw new ArgumentNullException(nameof(commandLineArgs));
+    /// <summary>Command line arguments</summary>
+    public string[] Arguments { get; } = arguments ?? throw new ArgumentNullException(nameof(arguments));
 
     /// <summary>Get the command line arguments count, excluding the implicit parameter at index 0</summary>
     public int ParameterCount =>
         Count - 1;
 
     /// <summary>Get the command line arguments count</summary>
     public int Count =>
-        CommandLineArgs.Length;
+        Arguments.Length;
 
     /// <summary>Determines whether the specified argument exists</summary>
     /// <param name="name">The argument</param>
     /// <returns>True if the specified argument exists</returns>
     private bool Contains(string name) =>
-        CommandLineArgs.FirstOrDefault(x => string.Equals(name, x, StringComparison.InvariantCultureIgnoreCase)) != null;
+        Arguments.FirstOrDefault(x => string.Equals(name, x, StringComparison.InvariantCultureIgnoreCase)) != null;
 
     /// <summary>Determines whether the specified argument exists</summary>
     /// <returns>True if the specified toggle exists</returns>
     public bool IsValidOrder()
     {
-        var arguments = CommandLineArgs;
         int? firstToggleIndex = null;
-        for (var i = 0; i < arguments.Length; i++)
+        for (var i = 0; i < Arguments.Length; i++)
         {
-            var argument = arguments[i];
+            var argument = Arguments[i];
             if (IsToggleArgument(argument))
             {
                 firstToggleIndex ??= i;
@@ -79,8 +79,8 @@ public string GetMember(int index, [CallerMemberName] string memberName = "", bo
 
     /// <summary>Gets the specified index, starting at 1</summary>
     /// <param name="index">The argument index</param>
-    /// <param name="name">The argument name (optional)</param>
-    /// <param name="allowToggle">Argument can be a toggle (optional)</param>
+    /// <param name="name">The argument name (default=null)</param>
+    /// <param name="allowToggle">Argument can be a toggle (default: false)</param>
     /// <returns>The argument value</returns>
     public string Get(int index, string name = null, bool allowToggle = false)
     {
@@ -89,7 +89,7 @@ public string Get(int index, string name = null, bool allowToggle = false)
             throw new ArgumentOutOfRangeException(nameof(index));
         }
 
-        if (CommandLineArgs.Length <= index || index >= CommandLineArgs.Length)
+        if (Arguments.Length <= index || index >= Arguments.Length)
         {
             return null;
         }
@@ -104,7 +104,7 @@ public string Get(int index, string name = null, bool allowToggle = false)
             }
         }
 
-        var arg = CommandLineArgs[index];
+        var arg = Arguments[index];
 
         // name
         if (name != null)
@@ -130,7 +130,7 @@ public string GetByName(string name)
             throw new ArgumentException(nameof(name));
         }
         var marker = $"{name}:";
-        foreach (var cmdLineArg in CommandLineArgs)
+        foreach (var cmdLineArg in Arguments)
         {
             if (cmdLineArg.StartsWith(marker, StringComparison.InvariantCultureIgnoreCase))
             {
@@ -249,7 +249,7 @@ public T GetEnum<T>(int index, T defaultValue, string name = null)
     /// <summary>Gets all toggle with fallback value</summary>
     /// <returns>The argument value</returns>
     public IEnumerable<string> GetToggles() =>
-        CommandLineArgs.Where(IsToggleArgument);
+        Arguments.Where(IsToggleArgument);
 
     /// <summary>Gets a toggle with fallback value</summary>
     /// <typeparam name="T">The enum type</typeparam>
@@ -265,10 +265,10 @@ public string TestUnknownToggles(IEnumerable<Type> enumTypes)
     {
         var enumTypesArray = enumTypes.ToArray();
         // test for unknown toggles
-        for (var i = 1; i < CommandLineArgs.Length; i++)
+        for (var i = 1; i < Arguments.Length; i++)
         {
             // command line argument
-            var arg = CommandLineArgs[i];
+            var arg = Arguments[i];
             if (!IsToggleArgument(arg))
             {
                 continue;
@@ -315,11 +315,11 @@ public Type TestMultipleToggles(IEnumerable<Type> enumTypes)
     /// </summary>
     public string[] GetArguments()
     {
-        if (commandLineArgs.Length <= 2)
+        if (arguments.Length <= 2)
         {
             return null;
         }
-        return CommandLineArgs.Skip(2).ToArray();
+        return Arguments.Skip(2).ToArray();
     }
 
     #region Static
@@ -328,6 +328,7 @@ public string[] GetArguments()
     public static CommandLineParser NewFromEnvironment() =>
         new(Environment.GetCommandLineArgs());
 
+
     /// <summary>New command line parser from command string</summary>
     public static CommandLineParser NewFromCommand(string command) =>
         new(SplitCommandArguments(command));

Client.Core/Command/CommandManager.cs

@@ -239,18 +239,29 @@ private async Task<int> ExecuteAsync(ICommand command, CommandLineParser command
 
     #region Command File
 
-    private class FileItem(string text, ICommand command, CommandLineParser parser)
+    private class FileItem
     {
-        public FileItem(string text, CommandLineParser parser, List<FileItem> children) :
+        public FileItem(string text, string path, CommandLineParser parser, List<FileItem> children) :
             this(text, null, parser)
         {
+            Path = path;
             Parser = parser;
             Children = children;
         }
 
-        internal string Text { get; } = text;
-        public ICommand Command { get; } = command;
-        public CommandLineParser Parser { get; } = parser;
+        // ReSharper disable once ConvertToPrimaryConstructor
+        public FileItem(string text, ICommand command, CommandLineParser parser)
+        {
+            Text = text;
+            Command = command;
+            Parser = parser;
+        }
+
+        // ReSharper disable once UnusedAutoPropertyAccessor.Local
+        internal string Text { get; }
+        internal string Path { get; }
+        public ICommand Command { get; }
+        public CommandLineParser Parser { get; }
         internal List<FileItem> Children { get; } = [];
     }
 
@@ -288,19 +299,19 @@ private async Task<int> ExecuteFileAsync(CommandLineParser parser, PayrollHttpCl
 
     private async Task<int> ExecuteFileItemAsync(FileItem item, PayrollHttpClient httpClient = null)
     {
-        // command
-        if (item.Command != null)
-        {
-            return await ExecuteAsync(item.Command, item.Parser, httpClient);
-        }
-
         // command file
         // working dir
         var currentDirectory = Directory.GetCurrentDirectory();
-        if (item.Parser.GetEnumToggle(PathChangeMode.ChangePath) == PathChangeMode.ChangePath)
+        if (!string.IsNullOrWhiteSpace(item.Path) &&
+            item.Parser.GetEnumToggle(PathChangeMode.ChangePath) == PathChangeMode.ChangePath)
+        {
+            EnsureCurrentDirectory(item.Path);
+        }
+
+        // command
+        if (item.Command != null)
         {
-            var directory = new FileInfo(item.Text).DirectoryName;
-            EnsureCurrentDirectory(directory);
+            return await ExecuteAsync(item.Command, item.Parser, httpClient);
         }
 
         // display
@@ -330,19 +341,47 @@ private async Task<int> ExecuteFileItemAsync(FileItem item, PayrollHttpClient ht
         return 0;
     }
 
-    private List<FileItem> ReadCommandFile(CommandLineParser fileParser)
+    private List<FileItem> ReadCommandFile(CommandLineParser parser, bool rootCommandFile = false)
     {
         // test file
-        var fileName = fileParser.Get(1);
+        var fileName = parser.Get(1);
         if (!IsCommandFile(fileName))
         {
             return null;
         }
 
+        var fileItems = new List<FileItem>();
         var info = new FileInfo(fileName);
         var fileBaseName = info.Name;
 
+        // command file
+        if (!rootCommandFile && IsCommandFile(fileName))
+        {
+            var parsedLine = ParseParameters(parser, fileName);
+            // transfer command line arguments
+            var lineParser = new CommandLineParser(parser.Arguments);
+
+            var linePathMode = lineParser.GetEnumToggle<PathChangeMode>(default);
+            Logger?.Trace($"Command file {fileName} (path-mode: {linePathMode})");
+            var commandFileItems = ReadCommandFile(lineParser, rootCommandFile: true);
+
+            // restore working dir
+            if (linePathMode == PathChangeMode.ChangePath)
+            {
+                EnsureCurrentDirectory(info.DirectoryName);
+            }
+
+            // add file item
+            if (commandFileItems != null)
+            {
+                var fileItem = new FileItem(parsedLine, info.DirectoryName, lineParser, commandFileItems);
+                fileItems.Add(fileItem);
+            }
+            return fileItems;
+        }
+
         // ensure working dir
+        var pathMode = parser.GetEnumToggle<PathChangeMode>(default);
         var startDirectory = Directory.GetCurrentDirectory();
         EnsureCurrentDirectory(info.DirectoryName);
         if (!File.Exists(fileBaseName))
@@ -352,9 +391,8 @@ private List<FileItem> ReadCommandFile(CommandLineParser fileParser)
         }
 
         // read commands
-        var fileItems = new List<FileItem>();
         var lines = File.ReadAllLines(fileBaseName).Select(x => x.Trim()).ToList();
-        Logger?.Trace($"Parsing command file {fileBaseName} ({lines.Count} lines)");
+        Logger?.Trace($"Parsing command file {fileBaseName} ({lines.Count} lines,  path-mode: {pathMode}))");
 
         var error = false;
         foreach (var line in lines)
@@ -365,24 +403,28 @@ private List<FileItem> ReadCommandFile(CommandLineParser fileParser)
                 continue;
             }
 
-            var parsedLine = ParseParameters(fileParser, line);
+            var parsedLine = ParseParameters(parser, line);
 
             var lineParser = CommandLineParser.NewFromCommand(parsedLine);
             var name = lineParser.Get(1);
 
             // command file
             if (IsCommandFile(name))
             {
-                Logger?.Trace($"Command file {fileName} command file: {parsedLine}");
                 var commandFileItems = ReadCommandFile(lineParser);
+                var linePathMode = lineParser.GetEnumToggle<PathChangeMode>(default);
+                Logger?.Trace($"Command file {fileName} command file: {parsedLine} (path-mode: {linePathMode})");
 
                 // restore working dir
-                EnsureCurrentDirectory(info.DirectoryName);
+                if (linePathMode == PathChangeMode.ChangePath)
+                {
+                    EnsureCurrentDirectory(info.DirectoryName);
+                }
 
                 // add file item
                 if (commandFileItems != null)
                 {
-                    var fileItem = new FileItem(parsedLine, lineParser, commandFileItems);
+                    var fileItem = new FileItem(parsedLine, info.DirectoryName, lineParser, commandFileItems);
                     fileItems.Add(fileItem);
                 }
                 continue;

Client.Core/ExceptionExtensions.cs

@@ -26,11 +26,14 @@ public static string GetApiErrorMessage(this Exception exception)
         {
             var buffer = new StringBuilder();
             buffer.AppendLine(apiError.Title);
-            foreach (var error in apiError.Errors)
+            if (apiError.Errors != null)
             {
-                foreach (var errorValue in error.Value)
+                foreach (var error in apiError.Errors)
                 {
-                    buffer.AppendLine($"{error.Key}: {errorValue.Trim()}");
+                    foreach (var errorValue in error.Value)
+                    {
+                        buffer.AppendLine($"{error.Key}: {errorValue.Trim()}");
+                    }
                 }
             }
             return buffer.ToString().Trim('\r', '\n', '"');
@@ -77,7 +80,7 @@ private static ApiError GetApiError(this Exception exception)
         try
         {
             var apiError = JsonSerializer.Deserialize<ApiError>(message);
-            if (apiError.Status != 0)
+            if (apiError != null && apiError.Status != 0)
             {
                 return apiError;
             }