550 lines
18 KiB
C#
550 lines
18 KiB
C#
using System;
|
|
using System.Text.RegularExpressions;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Net;
|
|
using System.Net.Security;
|
|
using System.Security.Cryptography.X509Certificates;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using Core.Main;
|
|
|
|
namespace Core.Helper {
|
|
|
|
public class SystemHelper {
|
|
private static bool AllwaysGoodCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors policyErrors) {
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks, if a string is numeric.
|
|
/// </summary>
|
|
/// <param name="s">The string to check.</param>
|
|
/// <returns>True, if the string is numeric.</returns>
|
|
public static bool IsNumeric(string s) {
|
|
try {
|
|
Int32.Parse(s);
|
|
} catch {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static bool IsInteger(double d) {
|
|
return d % 1 == 0;
|
|
}
|
|
|
|
public static bool IsBoolean(string s) {
|
|
try {
|
|
Boolean.Parse(s);
|
|
} catch {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks, if a string is a double value.
|
|
/// </summary>
|
|
/// <param name="s">The string to check.</param>
|
|
/// <returns>True, if the string is a double value.</returns>
|
|
public static bool IsDouble(string s) {
|
|
try {
|
|
Double.Parse(s);
|
|
} catch {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static bool IsDouble(string s, string culture) {
|
|
try {
|
|
Double.Parse(s, new CultureInfo(culture));
|
|
} catch {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks, if a string is a DateTime value.
|
|
/// </summary>
|
|
/// <param name="s">The string to check.</param>
|
|
/// <returns>True, if the string is a DateTime value.</returns>
|
|
public static bool IsDateTime(string s) {
|
|
try {
|
|
DateTime.Parse(s);
|
|
} catch {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Konvertiert einen Text zu einem Integer-Wert mit Fehlerbehandlung.
|
|
/// </summary>
|
|
/// <param name="text">Zu konvertierender Text.</param>
|
|
/// <param name="defaultValue">Der Vorgabewert für den Fall, dass keine gültige Zahl eingegeben wurde.</param>
|
|
/// <returns>Den Text als Integer. Wenn die Konvertierung fehlschlägt, dann wird der Defaultwert zurückgegeben.</returns>
|
|
public static int TextToInteger(string text, int defaultValue) {
|
|
int result = defaultValue;
|
|
try {
|
|
string localText = text.Replace(".", "");
|
|
result = Convert.ToInt32(localText.Trim());
|
|
} catch { }
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Konvertiert einen Text zu einem Integer64-Wert mit Fehlerbehandlung.
|
|
/// </summary>
|
|
/// <param name="text">Zu konvertierender Text.</param>
|
|
/// <param name="defaultValue">Der Vorgabewert für den Fall, dass keine gültige Zahl eingegeben wurde.</param>
|
|
/// <returns>Den Text als Integer64. Wenn die Konvertierung fehlschlägt, dann wird der Defaultwert zurückgegeben.</returns>
|
|
public static Int64 TextToInteger64(string text, Int64 defaultValue) {
|
|
Int64 result = defaultValue;
|
|
try {
|
|
string localText = text.Replace(".", "");
|
|
result = Convert.ToInt64(localText.Trim());
|
|
} catch { }
|
|
|
|
return result;
|
|
}
|
|
|
|
public static double TextToDouble(string text, double defaultValue, string culture) {
|
|
double result = defaultValue;
|
|
try {
|
|
if (!string.IsNullOrEmpty(text)) {
|
|
double.TryParse(text, NumberStyles.Any, new System.Globalization.CultureInfo(culture), out result);
|
|
}
|
|
} catch { }
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Konvertiert einen Text zu einem DateTime-Wert mit Fehlerbehandlung.
|
|
/// </summary>
|
|
/// <param name="text">Zu konvertierender Text.</param>
|
|
/// <param name="defaultValue">Der Vorgabewert für den Fall, dass keine gültige DateTime eingegeben wurde.</param>
|
|
/// <returns>Den Text als DateTime. Wenn die Konvertierung fehlschlägt, dann wird der Defaultwert zurückgegeben.</returns>
|
|
public static DateTime TextToDateTime(string text, DateTime defaultValue) {
|
|
DateTime result = defaultValue;
|
|
try {
|
|
result = Convert.ToDateTime(text.Trim());
|
|
} catch { }
|
|
|
|
return result;
|
|
}
|
|
|
|
public static DateTime TextToDateTime(string text, DateTime defaultValue, string culture) {
|
|
DateTime result = defaultValue;
|
|
try {
|
|
result = Convert.ToDateTime(text.Trim(), new System.Globalization.CultureInfo(culture));
|
|
} catch { }
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Konvertiert einen Text zu einem Boolean-Wert mit Fehlerbehandlung.
|
|
/// </summary>
|
|
/// <param name="text">Zu konvertierender Text.</param>
|
|
/// <param name="defaultValue">Der Vorgabewert für den Fall, dass keine gültige Boolean eingegeben wurde.</param>
|
|
/// <returns>Den Text als Boolean. Wenn die Konvertierung fehlschlägt, dann wird der Defaultwert zurückgegeben.</returns>
|
|
public static bool TextToBoolean(string text, bool defaultValue) {
|
|
bool result = defaultValue;
|
|
try {
|
|
result = Convert.ToBoolean(text.Trim());
|
|
} catch {
|
|
try {
|
|
int intValue = Convert.ToInt32(text.Trim());
|
|
result = intValue == 0 ? false : true;
|
|
} catch { }
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string SplitCamelCase(string s) {
|
|
string result = "";
|
|
|
|
string whiteList = "ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖßabcdefghijklmnopqrstuvwxyzäüö0123456789_- ";
|
|
|
|
if (!string.IsNullOrEmpty(s)) {
|
|
for (int i = 0; i < s.Length; i++) {
|
|
if (char.IsUpper(s[i]) || char.IsNumber(s[i])) {
|
|
if (i > 0 && whiteList.Contains(s[i - 1].ToString())) {
|
|
if (char.IsUpper(s[i])) {
|
|
if (!char.IsUpper(s[i - 1]) && !char.IsNumber(s[i - 1])) result += " ";
|
|
} else if (char.IsNumber(s[i])) {
|
|
if (!char.IsNumber(s[i - 1])) result += " ";
|
|
}
|
|
}
|
|
}
|
|
result += s[i].ToString();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears a string using a whitelist.
|
|
/// </summary>
|
|
/// <param name="text">Text to clear.</param>
|
|
/// <param name="allowedCharacters">Allowed characters.</param>
|
|
/// <returns>The cleared text.</returns>
|
|
public static string StripBadCode(string text, string allowedCharacters) {
|
|
StringBuilder sb = new StringBuilder();
|
|
if (text != null) {
|
|
for (int i = 0; i < text.Length; i++) {
|
|
if (allowedCharacters.Contains(text[i].ToString())) sb.Append(text[i]);
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static bool CheckForBadCode(string text, string allowedCharacters) {
|
|
bool result = false;
|
|
for (int i = 0; i < text.Length; i++) {
|
|
if (!allowedCharacters.Contains(text[i].ToString())) {
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Schneidet einen Text nach x Zeichen ab
|
|
/// </summary>
|
|
/// <param name="text">Der Text, der gekürzt werden soll.</param>
|
|
/// <param name="maxLength">Die maximale Länge, auf die der Text gekürzt werden soll.</param>
|
|
/// <returns>Der gekürzte Text.</returns>
|
|
public static string CutText(string text, int maxLength, bool addDots) {
|
|
string result = text;
|
|
|
|
if (result.Length > maxLength) {
|
|
result = result.Substring(0, maxLength);
|
|
|
|
if (addDots) result += "...";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ermittelt den Teilstring eines Zeitstring, der die Stunden darstellt.
|
|
/// </summary>
|
|
public static string GetHourFromString(string timeString) {
|
|
string result = "";
|
|
|
|
if (timeString.Contains(":")) {
|
|
string[] arrTime = timeString.Split(":".ToCharArray());
|
|
result = arrTime[0];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ermittelt den Teilstring eines Zeitstring, der die Minuten darstellt.
|
|
/// </summary>
|
|
public static string GetMinutesFromString(string timeString) {
|
|
string result = "";
|
|
|
|
if (timeString.Contains(":")) {
|
|
string[] arrTime = timeString.Split(":".ToCharArray());
|
|
result = arrTime[1];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static List<string> ConvertTokenStringToList(string tokenizedString, string separator) {
|
|
List<string> result = new List<string>();
|
|
|
|
if (!String.IsNullOrEmpty(tokenizedString) && !String.IsNullOrEmpty(separator)) {
|
|
string[] arrTokens = tokenizedString.Split(separator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
|
|
for (int i = 0; i < arrTokens.Length; i++) {
|
|
result.Add(arrTokens[i].Trim());
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static List<int> ConvertTokenStringToListInt(string tokenizedString, string separator) {
|
|
List<int> result = new List<int>();
|
|
|
|
if (!String.IsNullOrEmpty(tokenizedString) && !String.IsNullOrEmpty(separator)) {
|
|
string[] arrTokens = tokenizedString.Split(separator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
|
|
for (int i = 0; i < arrTokens.Length; i++) {
|
|
result.Add(Convert.ToInt32(arrTokens[i]));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string ConvertListToTokenString(List<string> tokenList, string separator, bool cropDoubleSeparators) {
|
|
string result = "";
|
|
|
|
if (tokenList.Count > 0) {
|
|
for (int i = 0; i < tokenList.Count; i++) {
|
|
result += tokenList[i].Trim() + separator;
|
|
}
|
|
|
|
if (cropDoubleSeparators)result = result.Replace(separator + separator, "");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string ConvertListToTokenString(List<int> tokenList, string separator) {
|
|
string result = "";
|
|
|
|
if (tokenList.Count > 0) {
|
|
for (int i = 0; i < tokenList.Count; i++) {
|
|
result += tokenList[i].ToString() + separator;
|
|
}
|
|
|
|
result += separator;
|
|
result = result.Replace(separator + separator, "");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static List<object> ConvertToObjectList<T>(List<T> inputList) {
|
|
List<object> result = new List<object>();
|
|
|
|
foreach (T item in inputList) {
|
|
result.Add(item);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static Hashtable ConvertTokenStringToHashtable(string tokenizedString, string pairSeparator, string fieldSeperator) {
|
|
Hashtable result = new Hashtable();
|
|
|
|
if (!String.IsNullOrEmpty(tokenizedString) && !String.IsNullOrEmpty(pairSeparator) && !String.IsNullOrEmpty(fieldSeperator)) {
|
|
string[] arrTokens = tokenizedString.Split(pairSeparator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
|
|
for (int i = 0; i < arrTokens.Length; i++) {
|
|
string[] arrKeyValuePair = arrTokens[i].Split(fieldSeperator.ToCharArray());
|
|
|
|
result.Add(arrKeyValuePair[0], arrKeyValuePair[1]);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string ConvertHashtableToTokenString(Hashtable tokenHashtable, string pairSeparator, string fieldSeperator) {
|
|
string result = "";
|
|
|
|
if (tokenHashtable.Keys.Count > 0) {
|
|
foreach (string key in tokenHashtable.Keys) {
|
|
result += key + fieldSeperator + tokenHashtable[key] + pairSeparator;
|
|
}
|
|
|
|
result += pairSeparator;
|
|
result = result.Replace(pairSeparator + pairSeparator, "");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetProperDurationTime(int durationSeconds, bool includeDays = true) {
|
|
string result = "";
|
|
|
|
int days = (int)Math.Floor((double)durationSeconds / (60.0 * 60.0 * 24.0));
|
|
if (!includeDays) days = 0;
|
|
|
|
int hours = (int)Math.Floor((double)durationSeconds / (60.0 * 60.0)) - days * 24;
|
|
int minutes = (int)Math.Floor((double)durationSeconds / 60.0) - (hours * 60) - (days * 24 * 60);
|
|
int seconds = durationSeconds - (minutes * 60) - (hours * 60 * 60) - (days * 24 * 60 * 60);
|
|
|
|
if (days > 0) {
|
|
result += days.ToString() + "d";
|
|
}
|
|
|
|
if (hours > 0) {
|
|
if (days > 0) result += " ";
|
|
result += hours.ToString() + "h";
|
|
}
|
|
|
|
if (minutes > 0) {
|
|
if (hours > 0 || days > 0) result += " ";
|
|
result += minutes.ToString() + "m";
|
|
}
|
|
|
|
if (seconds > 0) {
|
|
if (minutes > 0 || hours > 0 || days > 0) result += " ";
|
|
result += seconds.ToString() + "s";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static void AddValueToStringBuilder(StringBuilder sb, string value, int length, bool fillField, string delimiter) {
|
|
if (!string.IsNullOrEmpty(value)) {
|
|
if (value.Length > length)
|
|
sb.Append(value.Substring(0, length)); // Beschneiden
|
|
else {
|
|
if (fillField)
|
|
sb.Append(value.PadRight(length));
|
|
else
|
|
sb.Append(value);
|
|
}
|
|
} else {
|
|
if (fillField)
|
|
sb.Append(string.Empty.PadRight(length));
|
|
}
|
|
sb.Append(delimiter);
|
|
}
|
|
|
|
public static bool UrlIsReachable(string url) {
|
|
ServicePointManager.Expect100Continue = true;
|
|
ServicePointManager.DefaultConnectionLimit = 9999;
|
|
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
|
|
ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(AllwaysGoodCertificate);
|
|
|
|
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
|
|
request.Timeout = 10000;
|
|
request.Method = "GET";
|
|
|
|
try {
|
|
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) {
|
|
return response.StatusCode == HttpStatusCode.OK;
|
|
}
|
|
} catch (WebException) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static string GetMarketLink(string platform, string exchange, string market, string mainMarket) {
|
|
string result = "#";
|
|
if (platform.Equals("TradingView")) {
|
|
result = "https://www.tradingview.com/chart/?symbol=" + exchange.ToUpper() + ":";
|
|
|
|
string pairName = SystemHelper.StripBadCode(market, Constants.WhiteListMinimal);
|
|
|
|
if (pairName.StartsWith(mainMarket)) {
|
|
pairName = pairName.Replace(mainMarket, "") + mainMarket;
|
|
}
|
|
|
|
result += pairName;
|
|
} else {
|
|
switch (exchange) {
|
|
case "Bittrex":
|
|
result = "https://bittrex.com/Market/Index?MarketName=" + market;
|
|
break;
|
|
case "Binance":
|
|
result = "https://www.binance.com/trade.html?symbol=" + market;
|
|
break;
|
|
case "Poloniex":
|
|
result = "https://poloniex.com/exchange#" + market.ToLower();
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetFullMarketName(string mainMarket, string market, string exchange) {
|
|
string result = market;
|
|
|
|
switch (exchange) {
|
|
case "Bittrex":
|
|
result = mainMarket + "-" + market;
|
|
break;
|
|
case "Binance":
|
|
result = market + mainMarket;
|
|
break;
|
|
case "Poloniex":
|
|
result = mainMarket + "_" + market;
|
|
break;
|
|
}
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetTradingViewSymbol(string exchange, string market, string mainMarket) {
|
|
string result = exchange.ToUpper() + ":";
|
|
|
|
string pairName = SystemHelper.StripBadCode(market, Constants.WhiteListMinimal);
|
|
|
|
if (pairName.StartsWith(mainMarket)) {
|
|
pairName = pairName.Replace(mainMarket, "") + mainMarket;
|
|
}
|
|
|
|
result += pairName;
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetCurrencySymbol(string code) {
|
|
string result = code;
|
|
try {
|
|
System.Globalization.RegionInfo regionInfo = (from culture in System.Globalization.CultureInfo.GetCultures(System.Globalization.CultureTypes.AllCultures)
|
|
where culture.Name.Length > 0 && !culture.IsNeutralCulture
|
|
let region = new System.Globalization.RegionInfo(culture.LCID)
|
|
where String.Equals(region.ISOCurrencySymbol, code, StringComparison.InvariantCultureIgnoreCase)
|
|
select region).First();
|
|
result = regionInfo.CurrencySymbol;
|
|
} catch {
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string PropertyToString(object property) {
|
|
string result = property.ToString();
|
|
|
|
if (!property.ToString().Equals("true", StringComparison.InvariantCultureIgnoreCase) && !property.ToString().Equals("false", StringComparison.InvariantCultureIgnoreCase)) {
|
|
try {
|
|
double resultDouble = Convert.ToDouble(property);
|
|
result = resultDouble.ToString(new System.Globalization.CultureInfo("en-US"));
|
|
} catch {
|
|
}
|
|
} else {
|
|
result = property.ToString().ToLower();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static bool IsRecentVersion(string currentVersion, string latestVersion) {
|
|
bool result = true;
|
|
|
|
List<int> currentVersionInfo = SystemHelper.ConvertTokenStringToListInt(currentVersion, ".");
|
|
List<int> latestVersionInfo = SystemHelper.ConvertTokenStringToListInt(latestVersion, ".");
|
|
|
|
if (currentVersionInfo[0] < latestVersionInfo[0]) {
|
|
result = false;
|
|
}
|
|
|
|
if (currentVersionInfo[0] == latestVersionInfo[0] && currentVersionInfo[1] < latestVersionInfo[1]) {
|
|
result = false;
|
|
}
|
|
|
|
if (currentVersionInfo[0] == latestVersionInfo[0] && currentVersionInfo[1] == latestVersionInfo[1] && currentVersionInfo[2] < latestVersionInfo[2]) {
|
|
result = false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|