/// <summary>
///
/// </summary>
/// <param name="Base64"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string BASE64toTEXT(string Base64, string Error = Constants.ErrorMessage)
{
try
{
if (Base64.Length <= Constants.TextLength && Cores.UseCheck(Base64))
{
if (Base64.EndsWith("="))
{
try
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64)));
}
catch
{
try
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64 + "=")));
}
catch
{
try
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64.Remove(Base64.Length - 1))));
}
catch
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64.Remove(Base64.Length - 2))));
}
}
}
}
else
{
try
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64)));
}
catch
{
try
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64 + "=")));
}
catch
{
return(Encoding.UTF8.GetString(Convert.FromBase64String(Base64 + "==")));
}
}
}
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "CY-BTT1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="CHAR"></param>
/// <param name="Bracket"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string CHARtoASCII(string CHAR, char Bracket = ',', string Error = Constants.ErrorMessage)
{
try
{
if (CHAR.Length <= Constants.TextLength && Cores.UseCheck(CHAR, true))
{
string Result = string.Empty;
byte[] LetterByte;
for (int i = 0; i < CHAR.Length; i++)
{
LetterByte = UTF8Encoding.UTF8.GetBytes(CHAR.Substring(i, 1)); //Encoding.ASCII
if (i < CHAR.Length - 1)
{
Result += LetterByte[0] + Bracket.ToString();
}
else
{
Result += LetterByte[0].ToString();
}
}
return(Result);
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "US-CTA1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Text"></param>
/// <param name="Uppercase"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string TEXTtoSHA512(string Text, bool Uppercase = false, string Error = Constants.ErrorMessage)
{
try
{
if (Text.Length <= Constants.TextLength && Cores.UseCheck(Text, true))
{
using SHA512 SHA512 = SHA512.Create();
byte[] Result = SHA512.ComputeHash(ASCIIEncoding.ASCII.GetBytes(Text));
StringBuilder Builder = new();
for (int i = 0; i < Result.Length; i++)
{
Builder.Append(Result[i].ToString("x2"));
}
return(Uppercase == false?Builder.ToString().ToLowerInvariant() : Builder.ToString().ToUpperInvariant());
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "CY-TTS4!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Hex"></param>
/// <param name="Type"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string HEXtoRGB(string Hex, Enums.ColorType Type = Enums.ColorType.RGB1, string Error = Constants.ErrorMessage)
{
try
{
if ((Hex.Length == 6 && Cores.UseCheck(Hex)) || (Hex.Length == 7 && Hex.StartsWith("#") && Cores.UseCheck(Hex.Substring(1, Hex.Length - 1))))
{
System.Drawing.Color HexColor;
if (Hex.StartsWith("#"))
{
HexColor = ColorTranslator.FromHtml(Hex);
}
else
{
HexColor = ColorTranslator.FromHtml("#" + Hex);
}
return(Type switch
{
Enums.ColorType.RGB1 => HexColor.R + ", " + HexColor.G + ", " + HexColor.B,
Enums.ColorType.RGB2 => HexColor.R + " " + HexColor.G + " " + HexColor.B,
Enums.ColorType.RGB3 => HexColor.R + " - " + HexColor.G + " - " + HexColor.B,
Enums.ColorType.RRGGBB1 => "R: " + HexColor.R + ", G: " + HexColor.G + ", B: " + HexColor.B,
Enums.ColorType.RRGGBB2 => "R: " + HexColor.R + " G: " + HexColor.G + " B: " + HexColor.B,
Enums.ColorType.RRGGBB3 => "R: " + HexColor.R + " - G: " + HexColor.G + " - B: " + HexColor.B,
Enums.ColorType.RR => "R: " + HexColor.R,
Enums.ColorType.GG => "G: " + HexColor.G,
Enums.ColorType.BB => "B: " + HexColor.B,
Enums.ColorType.OnlyR => HexColor.R.ToString(),
Enums.ColorType.OnlyG => HexColor.G.ToString(),
Enums.ColorType.OnlyB => HexColor.B.ToString(),
_ => Error,
});
}
/// <summary>
///
/// </summary>
/// <param name="ASCII"></param>
/// <param name="Bracket"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string ASCIItoCHAR(string ASCII, char Bracket = ',', string Error = Constants.ErrorMessage)
{
try
{
if (ASCII.Length <= Constants.TextLength && Cores.UseCheck(ASCII, Bracket == ' '))
{
string Result = string.Empty;
if (ASCII.Contains(Bracket.ToString()))
{
string[] Letters = ASCII.Split(Bracket);
for (int i = 0; i < Letters.Length; i++)
{
if (Cores.NumberCheck(Letters[i], false, Enums.IntType.Int32) && Letters[i].Length >= 1 && Letters[i].Length <= 3 && Convert.ToInt32(Letters[i]) >= 0 && Convert.ToInt32(Letters[i]) <= 255)
{
Result += UTF8Encoding.UTF8.GetString(new byte[] { Convert.ToByte(Letters[i]) }); //Encoding.ASCII
}
else
{
return(Error);
}
}
}
else
{
if (Cores.NumberCheck(ASCII, false, Enums.IntType.Int32) && ASCII.Length >= 1 && ASCII.Length <= 3 && Convert.ToInt32(ASCII) >= 0 && Convert.ToInt32(ASCII) <= 255)
{
Result = UTF8Encoding.UTF8.GetString(new byte[] { Convert.ToByte(ASCII) }); //Encoding.ASCII
}
else
{
return(Error);
}
}
return(Result);
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "US-ATC1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Text"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string TEXTtoBASE64(string Text, string Error = Constants.ErrorMessage)
{
try
{
if (Text.Length <= Constants.TextLength && Cores.UseCheck(Text, true))
{
return(Convert.ToBase64String(Encoding.UTF8.GetBytes(Text)));
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "CY-TTB1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Fahrenheit"></param>
/// <param name="Decimal"></param>
/// <param name="Comma"></param>
/// <param name="PostComma"></param>
/// <param name="Text"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string FtoC(string Fahrenheit, bool Decimal, bool Comma, int PostComma = 0, bool Text = true, string Error = Constants.ErrorMessage)
{
try
{
if (Fahrenheit.Length <= Constants.VariableLength && Cores.NumberCheck(Fahrenheit) && !Fahrenheit.StartsWith("0") && PostComma >= Constants.PostCommaMinimum && PostComma <= Constants.PostCommaMaximum && Cores.UseCheck(Fahrenheit))
{
if (Convert.ToInt64(Fahrenheit) >= 32)
{
if (Text)
{
return(Cores.LastCheck2(((Convert.ToDouble(Fahrenheit) - Convert.ToInt32(Values.GetValue("Temperature", "Fahrenheit", "Deduct", Error))) * Convert.ToInt32(Values.GetValue("Temperature", "Fahrenheit", "Multipy", Error)) / Convert.ToInt32(Values.GetValue("Temperature", "Fahrenheit", "Divide", Error))).ToString(), Decimal, Comma, PostComma, Error) + " C");
}
else
{
return(Cores.LastCheck2(((Convert.ToDouble(Fahrenheit) - Convert.ToInt32(Values.GetValue("Temperature", "Fahrenheit", "Deduct", Error))) * Convert.ToInt32(Values.GetValue("Temperature", "Fahrenheit", "Multipy", Error)) / Convert.ToInt32(Values.GetValue("Temperature", "Fahrenheit", "Divide", Error))).ToString(), Decimal, Comma, PostComma, Error));
}
}
else
{
if (Text)
{
return(Cores.LastCheck2("0", Decimal, Comma, PostComma, Error) + " C");
}
else
{
return(Cores.LastCheck2("0", Decimal, Comma, PostComma, Error));
}
}
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "TE-FTC1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Celsius"></param>
/// <param name="Decimal"></param>
/// <param name="Comma"></param>
/// <param name="PostComma"></param>
/// <param name="Text"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string CtoF(string Celsius, bool Decimal, bool Comma, int PostComma = 0, bool Text = true, string Error = Constants.ErrorMessage)
{
try
{
if (Celsius.Length <= Constants.VariableLength && Cores.NumberCheck(Celsius) && !Celsius.StartsWith("0") && PostComma >= Constants.PostCommaMinimum && PostComma <= Constants.PostCommaMaximum && Cores.UseCheck(Celsius))
{
if (Text)
{
return(Cores.LastCheck2((Convert.ToDouble(Celsius) / Convert.ToInt32(Values.GetValue("Temperature", "Celsius", "Divide", Error)) * Convert.ToInt32(Values.GetValue("Temperature", "Celsius", "Multipy", Error)) + Convert.ToInt32(Values.GetValue("Temperature", "Celsius", "Add", Error))).ToString(), Decimal, Comma, PostComma, Error) + " F");
}
else
{
return(Cores.LastCheck2((Convert.ToDouble(Celsius) / Convert.ToInt32(Values.GetValue("Temperature", "Celsius", "Divide", Error)) * Convert.ToInt32(Values.GetValue("Temperature", "Celsius", "Multipy", Error)) + Convert.ToInt32(Values.GetValue("Temperature", "Celsius", "Add", Error))).ToString(), Decimal, Comma, PostComma, Error));
}
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "TE-CTF1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Centimeter"></param>
/// <param name="Decimal"></param>
/// <param name="Comma"></param>
/// <param name="PostComma"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string CMtoINCH(string Centimeter, bool Decimal, bool Comma, int PostComma = 0, string Error = Constants.ErrorMessage)
{
try
{
if (Centimeter.Length <= Constants.VariableLength && Cores.NumberCheck(Centimeter) && !Centimeter.StartsWith("0") && PostComma >= Constants.PostCommaMinimum && PostComma <= Constants.PostCommaMaximum && Cores.UseCheck(Centimeter))
{
if (Convert.ToInt64(Centimeter) >= 3)
{
return(Cores.LastCheck2((Convert.ToInt64(Centimeter) * Convert.ToDouble(Values.GetValue("Typography", "CM", "INCH", Error))).ToString(), Decimal, Comma, PostComma, Error));
}
else
{
return(Cores.LastCheck2("0", Decimal, Comma, PostComma, Error));
}
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "TY-CTI1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Inch"></param>
/// <param name="Decimal"></param>
/// <param name="Comma"></param>
/// <param name="PostComma"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string INCHtoPX(string Inch, bool Decimal, bool Comma, int PostComma = 0, string Error = Constants.ErrorMessage)
{
try
{
if (Inch.Length <= Constants.VariableLength && Cores.NumberCheck(Inch) && !Inch.StartsWith("0") && PostComma >= Constants.PostCommaMinimum && PostComma <= Constants.PostCommaMaximum && Cores.UseCheck(Inch))
{
string Result = (Convert.ToInt64(Inch) * Convert.ToDouble(Values.GetValue("Typography", "INCH", "PX", Error))).ToString();
return(Cores.LastCheck2(Result, Decimal, Comma, PostComma, Error));
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "TY-ITP1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Pixel"></param>
/// <param name="Decimal"></param>
/// <param name="Comma"></param>
/// <param name="PostComma"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string PXtoCM(string Pixel, bool Decimal, bool Comma, int PostComma = 0, string Error = Constants.ErrorMessage)
{
try
{
if (Pixel.Length <= Constants.VariableLength && Cores.NumberCheck(Pixel) && !Pixel.StartsWith("0") && PostComma >= Constants.PostCommaMinimum && PostComma <= Constants.PostCommaMaximum && Cores.UseCheck(Pixel))
{
if (Convert.ToInt64(Pixel) >= 38)
{
return(Cores.LastCheck2((Convert.ToInt64(Pixel) * Convert.ToDouble(Values.GetValue("Typography", "PX", "CM", Error))).ToString(), Decimal, Comma, PostComma, Error));
}
else
{
return(Cores.LastCheck2("0", Decimal, Comma, PostComma, Error));
}
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "TY-PTC1!)");
}
}
/// <summary>
///
/// </summary>
/// <param name="Kilometers"></param>
/// <param name="Decimal"></param>
/// <param name="Comma"></param>
/// <param name="PostComma"></param>
/// <param name="Text"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string KPHtoMPH(string Kilometers, bool Decimal, bool Comma, int PostComma = 0, bool Text = true, string Error = Constants.ErrorMessage)
{
try
{
if (Kilometers.Length <= Constants.VariableLength && Cores.NumberCheck(Kilometers) && !Kilometers.StartsWith("0") && PostComma >= Constants.PostCommaMinimum && PostComma <= Constants.PostCommaMaximum && Cores.UseCheck(Kilometers))
{
if (Text)
{
return(Cores.LastCheck2((Convert.ToDouble(Kilometers) * Convert.ToDouble(Values.GetValue("Speed", "KPH", "MPH", Error))).ToString(), Decimal, Comma, PostComma, Error) + " MPH");
}
else
{
return(Cores.LastCheck2((Convert.ToDouble(Kilometers) * Convert.ToDouble(Values.GetValue("Speed", "KPH", "MPH", Error))).ToString(), Decimal, Comma, PostComma, Error));
}
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "SD-KTM1!)");
}
}
