(#2829) Adds Basic choco license Command

This commit introduces a new command to Chocolatey, `license`.

Currently, the functionality is limited, and it will only
display details on the current license.

Author: JPRuskin

src/chocolatey/chocolatey.csproj

@@ -178,6 +178,7 @@
     <Compile Include="AssemblyExtensions.cs" />
     <Compile Include="ExceptionExtensions.cs" />
     <Compile Include="infrastructure.app\attributes\MultiServiceAttribute.cs" />
+    <Compile Include="infrastructure.app\commands\ChocolateyLicenseCommand.cs" />
     <Compile Include="infrastructure.app\commands\ChocolateyCacheCommand.cs" />
     <Compile Include="infrastructure.app\commands\ChocolateyListCommand.cs" />
     <Compile Include="infrastructure.app\commands\ChocolateyRuleCommand.cs" />

src/chocolatey/infrastructure.app/commands/ChocolateyLicenseCommand.cs

@@ -0,0 +1,167 @@
+// Copyright © 2017 - 2025 Chocolatey Software, Inc
+// Copyright © 2011 - 2017 RealDimensions Software, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+//
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using chocolatey.infrastructure.app.attributes;
+using chocolatey.infrastructure.app.configuration;
+using chocolatey.infrastructure.commandline;
+using chocolatey.infrastructure.commands;
+using chocolatey.infrastructure.licensing;
+using chocolatey.infrastructure.logging;
+
+namespace chocolatey.infrastructure.app.commands
+{
+    [CommandFor("license", "Retrieve Chocolatey License information", Version = "2.5.0")]
+    public class ChocolateyLicenseCommand : ICommand
+    {
+        public void ConfigureArgumentParser(OptionSet optionSet, ChocolateyConfiguration configuration)
+        {
+            // We don't currently expect to have any arguments
+        }
+
+        public void ParseAdditionalArguments(IList<string> unparsedArguments, ChocolateyConfiguration configuration)
+        {
+            // We don't currently expect to have any additional arguments
+        }
+
+        public void Validate(ChocolateyConfiguration configuration)
+        {
+            // We don't currently accept any arguments, so there is no validation
+        }
+
+        public void HelpMessage(ChocolateyConfiguration configuration)
+        {
+            this.Log().Info(ChocolateyLoggers.Important, "License Command");
+            this.Log().Info(@"
+Chocolatey will do license things.
+");
+        }
+
+        public bool MayRequireAdminAccess()
+        {
+            return false;
+        }
+
+        public void DryRun(ChocolateyConfiguration configuration)
+        {
+        }
+
+        public void Run(ChocolateyConfiguration config)
+        {
+            var ourLicense = LicenseValidation.Validate();
+            var nodeCount = ParseNodeCountFromLicenseName(ourLicense.Name);
+            var logger = config.RegularOutput ? ChocolateyLoggers.Normal : ChocolateyLoggers.LogFileOnly;
+
+            if (ourLicense.LicenseType == ChocolateyLicenseType.Foss)
+            {
+                this.Log().Warn(logger, "No Commercial License Found, running with Open Source License.");
+                return;
+            }
+
+            if (!ourLicense.IsValid)
+            {
+                this.Log().Warn(logger, "We have found an invalid license for Chocolatey {0}: {1}", ourLicense.LicenseType, ourLicense.InvalidReason);
+                Environment.ExitCode = 1;
+            }
+
+            if (config.RegularOutput)
+            {
+                this.Log().Info("Registered to:   {0}".FormatWith(ourLicense.Name));
+                this.Log().Info("Expiration Date: {0} UTC".FormatWith(ourLicense.ExpirationDate));
+                this.Log().Info("License type:    {0}".FormatWith(ourLicense.LicenseType));
+                this.Log().Info("Node Count:      {0}".FormatWith(nodeCount));
+            }
+            else
+            {
+                // Headers: Name, LicenseType, ExpirationDate, NodeCount
+                this.Log().Info("{0}|{1}|{2}|{3}".FormatWith(ourLicense.Name, ourLicense.LicenseType, ourLicense.ExpirationDate, nodeCount));
+            }
+        }
+
+        private int? ParseNodeCountFromLicenseName(string licenseName)
+        {
+            if (string.IsNullOrWhiteSpace(licenseName))
+            {
+                return null;
+            }
+
+            // Starting from the beginning of the license name
+            var startIndex = 0;
+            // while the start index is less than the length of the string
+            // and there is a '[' in the name
+            while (startIndex < licenseName.Length && (startIndex = licenseName.IndexOf('[', startIndex)) > -1)
+            {
+                var endIndex = 1;
+                // increment endIndex (which is actually a relative position) while the next digit is still a digit
+                while (startIndex + endIndex < licenseName.Length && char.IsDigit(licenseName[startIndex + endIndex]))
+                {
+                    endIndex++;
+                }
+
+                // If the length of the string is greater or equal than the length of the name, stop!
+                if (licenseName.Length <= startIndex + endIndex)
+                {
+                    break;
+                }
+
+                // If next character is ']', return the content within the square braces
+                if (licenseName[startIndex + endIndex] == ']')
+                {
+                    return int.Parse(licenseName.Substring(startIndex + 1, endIndex - 1));
+                }
+
+                // If we get this far, start testing at the end of the current range
+                startIndex = startIndex + endIndex;
+            }
+
+            return null;
+
+        }
+
+#pragma warning disable IDE0022, IDE1006
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual void configure_argument_parser(OptionSet optionSet, ChocolateyConfiguration configuration)
+            => ConfigureArgumentParser(optionSet, configuration);
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual void handle_additional_argument_parsing(IList<string> unparsedArguments, ChocolateyConfiguration configuration)
+            => ParseAdditionalArguments(unparsedArguments, configuration);
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual void handle_validation(ChocolateyConfiguration configuration)
+            => Validate(configuration);
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual void help_message(ChocolateyConfiguration configuration)
+            => HelpMessage(configuration);
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual bool may_require_admin_access()
+            => MayRequireAdminAccess();
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual void noop(ChocolateyConfiguration configuration)
+            => DryRun(configuration);
+
+        [Obsolete("This overload is deprecated and will be removed in v3.")]
+        public virtual void run(ChocolateyConfiguration configuration)
+            => Run(configuration);
+
+#pragma warning restore IDE0022, IDE1006
+    }
+}