Merge pull request #36 from I-RzR-I/feature/AddBase32Byte

Feature/add base32 byte

Author: I-RzR-I

docs/CHANGELOG.md

@@ -1,3 +1,10 @@
+### **v3.1.0.3090** [[RzR](mailto:108324929+I-RzR-I@users.noreply.github.com)] 13-08-2025
+* [bc2ef6d] (RzR) -> Auto commit uncommited files
+* [90ce1ef] (RzR) -> Add and adjust test methods.
+* [e8fafdc] (RzR) -> Add DateTime method: `Epoch`.
+* [8bb8672] (RzR) -> Add byte method: `Base32BytesToString`.
+* [896be11] (RzR) -> Add string methods `IsBase32String`, `Base32ToBytes` and adjust `TrimAndReduceSpace`, `TrimAndReplaceSpecialCharacters`.
+
 ### **v3.0.0.3007** [[RzR](mailto:108324929+I-RzR-I@users.noreply.github.com)] 07-08-2025
 * [9e7a5e9] (RzR) -> Auto commit uncommited files.
 * [ddc61a0] (RzR) -> Add new reflection extension methods (available from net45 and up); `GetTypes`, `GetSetMethod`, `GetGetMethod`, `GetGenericArguments`, `GetMethod`, `GetMembers`, `GetInterfaces`, `IsGenericType`, `IsValueType`, `IsAbstract`, `IsAssignableFrom`, `ContainsGenericParameters`, `BaseType`, `IsGenericTypeDefinition`, `IsPrimitive`, `IsNestedPublic`, `IsPublic`, `IsSealed`, `GetGenericParameterConstraints`, `IsClass`, `IsInterface`, `IsGenericParameter`, `GetGenericParameterAttributes`, `GetAssembly`, `GetConstructors`, `GetConstructor`, `IsInNamespace`.

src/DomainCommonExtensions/DataTypeExtensions/ByteExtensions.cs

@@ -24,6 +24,8 @@
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
+using DomainCommonExtensions.ArraysExtensions;
+using DomainCommonExtensions.Helpers.Internal;
 using DomainCommonExtensions.Utilities.Ensure;
 
 #endregion
@@ -188,5 +190,49 @@ public static byte[] GZipCompress(this byte[] source, CompressionLevel compressi
             return memory.ToArray();
         }
 #endif
+
+        /// <summary>
+        ///     Convert byte[] to BASE32 string
+        /// </summary>
+        /// <param name="sourceBytes">The sourceBytes to act on.</param>
+        /// <returns>
+        ///     A BASE32 string.
+        /// </returns>
+        public static string Base32BytesToString(this byte[] sourceBytes)
+        {
+            if(sourceBytes.IsNullOrEmptyEnumerable())
+                DomainEnsure.IsNotNull(sourceBytes, nameof(sourceBytes));
+
+            var charCount = (int)Math.Ceiling(sourceBytes.Length / 5D) * 8;
+            var returnArray = new char[charCount];
+
+            byte nextChar = 0, bitsRemaining = 5;
+            var arrayIndex = 0;
+
+            foreach (var byteItem in sourceBytes)
+            {
+                nextChar = (byte)(nextChar | (byteItem >> (8 - bitsRemaining)));
+                returnArray[arrayIndex++] = Base32EncodingHelper.ByteToChar(nextChar);
+
+                if (bitsRemaining < 4)
+                {
+                    nextChar = (byte)((byteItem >> (3 - bitsRemaining)) & 31);
+                    returnArray[arrayIndex++] = Base32EncodingHelper.ByteToChar(nextChar);
+                    bitsRemaining += 5;
+                }
+
+                bitsRemaining -= 3;
+                nextChar = (byte)((byteItem << bitsRemaining) & 31);
+            }
+
+            if (arrayIndex.Equals(charCount).IsFalse())
+            {
+                returnArray[arrayIndex++] = Base32EncodingHelper.ByteToChar(nextChar);
+                while (arrayIndex != charCount) 
+                    returnArray[arrayIndex++] = '=';
+            }
+
+            return new string(returnArray);
+        }
     }
 }

src/DomainCommonExtensions/DataTypeExtensions/DateTimeExtensions.cs

@@ -524,5 +524,14 @@ public static double ToExcelTime(this DateTime sourceTime)
 
             return t.TotalDays;
         }
+
+        /// <summary>
+        ///     Return always epoch date and time. Source DateTime will be ignored.
+        /// </summary>
+        /// <param name="sourceTime">Source date time</param>
+        /// <returns>Return always epoch date.</returns>
+        /// <remarks></remarks>
+        public static DateTime Epoch(this DateTime sourceTime) 
+            => new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
     }
 }

src/DomainCommonExtensions/DataTypeExtensions/StringExtensions.cs

@@ -36,6 +36,7 @@
 using CodeSource;
 using DomainCommonExtensions.ArraysExtensions;
 using DomainCommonExtensions.CommonExtensions;
+using DomainCommonExtensions.Helpers.Internal;
 using DomainCommonExtensions.Resources;
 using DomainCommonExtensions.Resources.Enums;
 using DomainCommonExtensions.Utilities.Ensure;
@@ -117,7 +118,7 @@ public static bool IsValidEmail(this string email)
         /// <returns></returns>
         public static SecureString ToSecureString(this string str)
         {
-            DomainEnsure.ThrowExceptionIfFuncIsTrue(ExceptionType.ArgumentNullException, 
+            DomainEnsure.ThrowExceptionIfFuncIsTrue(ExceptionType.ArgumentNullException,
                 str.IsMissing, str, nameof(str));
 
             var secureString = new SecureString();
@@ -340,13 +341,17 @@ public static string TrimIfNotNull(this string value)
         ///     Trim and reduce space from string
         /// </summary>
         /// <param name="value">Input value</param>
+        /// <param name="reduceAllSpaces">
+        ///     Reduce/remove all spaces from source string data.
+        ///     Default value is 'false'.
+        /// </param>
         /// <returns></returns>
         /// <remarks></remarks>
-        public static string TrimAndReduceSpace(this string value)
+        public static string TrimAndReduceSpace(this string value, bool reduceAllSpaces = false)
         {
             if (value.IfNullThenEmpty().IsMissing()) return null;
 
-            return Regex.Replace(value, @"\s+", " ").TrimIfNotNull();
+            return Regex.Replace(value, @"\s+", reduceAllSpaces.IsTrue() ? "" : " ").TrimIfNotNull();
         }
 
         /// <summary>
@@ -504,11 +509,15 @@ public static string RemoveSpecialChars(this string str)
         ///     Trim and replace special characters in string
         /// </summary>
         /// <param name="value">Input string</param>
+        /// <param name="reduceAllSpaces">
+        ///     Reduce/remove all spaces from source string data.
+        ///     Default value is 'false'.
+        /// </param>
         /// <returns></returns>
         /// <remarks></remarks>
-        public static string TrimAndReplaceSpecialCharacters(this string value)
+        public static string TrimAndReplaceSpecialCharacters(this string value, bool reduceAllSpaces = false)
         {
-            return value.TrimAndReduceSpace().RemoveSpecialChars();
+            return value.TrimAndReduceSpace(reduceAllSpaces).RemoveSpecialChars();
         }
 
         /// <summary>
@@ -1637,5 +1646,67 @@ public static string IfNotStartsWith(this string source, string searchValue, str
         {
             return source.StartsWith(searchValue).IsFalse() ? resultValue : source;
         }
+
+
+        /// <summary>
+        ///     Check if string is in BASE32 format
+        /// </summary>
+        /// <param name="base32String">Encoded BASE32 string</param>
+        /// <returns></returns>
+        /// <remarks></remarks>
+        public static bool IsBase32String(this string base32String)
+        {
+            if (base32String.IsNullOrEmpty()) return false;
+
+            base32String = base32String.TrimIfNotNull();
+
+            return (base32String.Length % 8).IsZero() &&
+                   Regex.IsMatch(base32String, RegularExpressions.BASE32, RegexOptions.None);
+        }
+
+        /// <summary>
+        ///     Convert BASE32 string to byte[]
+        /// </summary>
+        /// <param name="base32String">Encoded BASE32 string.</param>
+        /// <returns>
+        ///     A byte[].
+        /// </returns>
+        public static byte[] Base32ToBytes(this string base32String)
+        {
+            DomainEnsure.IsNotNullOrEmptyArgNull(base32String, nameof(base32String));
+
+            base32String = base32String.TrimEnd('=');
+            var byteCount = base32String.Length * 5 / 8;
+            var returnArray = new byte[byteCount];
+
+            byte curByte = 0, bitsRemaining = 8;
+            var arrayIndex = 0;
+
+            foreach (var character in base32String)
+            {
+                var charValue = Base32EncodingHelper.CharToInt32(character);
+
+                int mask;
+                if (bitsRemaining > 5)
+                {
+                    mask = charValue << (bitsRemaining - 5);
+                    curByte = (byte)(curByte | mask);
+                    bitsRemaining -= 5;
+                }
+                else
+                {
+                    mask = charValue >> (5 - bitsRemaining);
+                    curByte = (byte)(curByte | mask);
+                    returnArray[arrayIndex++] = curByte;
+                    curByte = (byte)(charValue << (3 + bitsRemaining));
+                    bitsRemaining += 3;
+                }
+            }
+
+            if (arrayIndex.Equals(byteCount).IsFalse())
+                returnArray[arrayIndex] = curByte;
+
+            return returnArray;
+        }
     }
 }

src/DomainCommonExtensions/Helpers/Internal/Base32EncodingHelper.cs

@@ -0,0 +1,83 @@
+// ***********************************************************************
+//  Assembly         : RzR.Shared.Extensions.DomainCommonExtensions
+//  Author           : RzR
+//  Created On       : 2025-08-13 00:12
+// 
+//  Last Modified By : RzR
+//  Last Modified On : 2025-08-13 00:16
+// ***********************************************************************
+//  <copyright file="Base32EncodingHelper.cs" company="RzR SOFT & TECH">
+//   Copyright © RzR. All rights reserved.
+//  </copyright>
+// 
+//  <summary>
+//  </summary>
+// ***********************************************************************
+
+#region U S A G E S
+
+using System;
+using DomainCommonExtensions.DataTypeExtensions;
+
+#endregion
+
+namespace DomainCommonExtensions.Helpers.Internal
+{
+    /// -------------------------------------------------------------------------------------------------
+    /// <summary>
+    ///     A base 32 encoding helper.
+    /// </summary>
+    /// =================================================================================================
+    internal static class Base32EncodingHelper
+    {
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     A char extension method that character to int 32.
+        /// </summary>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when one or more arguments have unsupported or illegal values.
+        /// </exception>
+        /// <param name="sourceChar">The sourceChar to act on.</param>
+        /// <returns>
+        ///     An int.
+        /// </returns>
+        /// =================================================================================================
+        internal static int CharToInt32(char sourceChar)
+        {
+            var value = (int)sourceChar;
+
+            return value switch
+            {
+                //65-90 == uppercase letters
+                < 91 and > 64 => value - 65,
+                //50-55 == numbers 2-7
+                < 56 and > 49 => value - 24,
+                //97-122 == lowercase letters
+                < 123 and > 96 => value - 97,
+                _ => throw new ArgumentException("Supplied character is not a valid value of BASE32.", nameof(sourceChar))
+            };
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     A byte extension method that byte to character.
+        /// </summary>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when one or more arguments have unsupported or illegal values.
+        /// </exception>
+        /// <param name="sourceByte">The sourceByte to act on.</param>
+        /// <returns>
+        ///     A char.
+        /// </returns>
+        /// =================================================================================================
+        internal static char ByteToChar(byte sourceByte)
+        {
+            return sourceByte switch
+            {
+                < 26 => (char)(sourceByte + 65),
+                < 32 => (char)(sourceByte + 24),
+                _ => throw new ArgumentException("Supplied byte is not a valid value of BASE32.", nameof(sourceByte))
+            };
+        }
+    }
+}

src/DomainCommonExtensions/Resources/RegularExpressions.cs

@@ -62,5 +62,10 @@ public struct RegularExpressions
         ///     BASE 64 regex
         /// </summary>
         public const string BASE64 = @"^[a-zA-Z0-9\+/]*={0,3}$";
+
+        /// <summary>
+        ///     BASE 32 regex
+        /// </summary>
+        public const string BASE32 = @"^[A-Z2-7]+(?:={1,6})?$";
     }
 }

src/shared/GeneralAssemblyInfo.cs

@@ -47,6 +47,6 @@
 [assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.MainAssembly)]
 #endif
 
-[assembly: AssemblyVersion("3.0.0.3007")]
-[assembly: AssemblyFileVersion("3.0.0.3007")]
-[assembly: AssemblyInformationalVersion("3.0.0.3007")]
+[assembly: AssemblyVersion("3.1.0.3090")]
+[assembly: AssemblyFileVersion("3.1.0.3090")]
+[assembly: AssemblyInformationalVersion("3.1.0.3090")]

src/tests/DataTypeTests/DataTests/DateTimeTests.cs

@@ -314,5 +314,14 @@ public void AsNotNull_CustomDate_Test()
             Assert.IsNotNull(newDt);
             Assert.AreEqual(newDt, customDt);
         }
+
+        [TestMethod]
+        public void Epoch_Test()
+        {
+            var epoch = DateTime.Now.Epoch();
+
+            Assert.IsNotNull(epoch);
+            Assert.AreEqual(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc), epoch);
+        }
     }
 }

src/tests/DataTypeTests/DataTests/StringTests.cs

@@ -240,6 +240,7 @@ public void TrimIfNotNullEmptyValueTest()
             var inpValue = " test ".TrimIfNotNull();
 
             Assert.IsTrue(inpValue.Length == 4);
+            Assert.AreEqual("test", inpValue);
         }
 
         [TestMethod]
@@ -248,6 +249,16 @@ public void TrimAndReduceSpaceTest()
             var inpValue = " Input test data  ".TrimAndReduceSpace();
 
             Assert.IsTrue(inpValue.Length == 15);
+            Assert.AreEqual("Input test data", inpValue);
+        }
+
+        [TestMethod]
+        public void TrimAndReduceSpace_ReduceAllSpaces_Test()
+        {
+            var inpValue = " Input test data  ".TrimAndReduceSpace(true);
+
+            Assert.IsTrue(inpValue.Length == 13);
+            Assert.AreEqual("Inputtestdata", inpValue);
         }
 
         [TestMethod]
@@ -416,6 +427,19 @@ public void IsBase64StringTest()
             Assert.IsFalse(clearTest);
         }
 
+        [TestMethod]
+        public void IsBase32StringTest()
+        {
+            var clear = "Clear text test 001?!";
+            var b32 = "INWGKYLSEB2GK6DUEB2GK43UEAYDAMJ7EE======";
+
+            var clearTest = clear.IsBase32String();
+            var b32Test = b32.IsBase32String();
+
+            Assert.IsTrue(b32Test);
+            Assert.IsFalse(clearTest);
+        }
+
         [TestMethod]
         public void ReplaceSpecialCharactersTest()
         {
@@ -579,5 +603,17 @@ public void IfNotContains_Test(string source, string checkValue, string excepted
             Assert.IsNotNull(res);
             Assert.AreEqual(exceptedResult, res);
         }
+
+        [DataRow("INWGKYLSEB2GK6DUEB2GK43UEAYDAMJ7EE======")]
+        [TestMethod]
+        public void Base32StringToByteAndBack_Test(string base32String)
+        {
+            var byteArray = base32String.Base32ToBytes();
+            Assert.IsNotNull(byteArray);
+
+            var decoded = byteArray.Base32BytesToString();
+            Assert.IsNotNull(decoded);
+            Assert.AreEqual(base32String, decoded);
+        }
     }
 }