566 lines
18 KiB
C#
566 lines
18 KiB
C#
using System;
|
|
using System.Text;
|
|
using System.IO.Compression;
|
|
using System.IO;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using Microsoft.Win32;
|
|
using System.Diagnostics;
|
|
using System.Collections.Generic;
|
|
using MarketData.MarketDataModel;
|
|
|
|
namespace MarketData.Utils
|
|
{
|
|
public class Utility
|
|
{
|
|
private static DateTime epoch = DateTime.Parse("01-01-0001");
|
|
private static TimeSpan oneDay=new TimeSpan(1,0,0,0);
|
|
public static String Pad(string str, char filler, int length)
|
|
{
|
|
int stringLength = str.Length;
|
|
if (stringLength >= length) return str;
|
|
StringBuilder sb = new StringBuilder();
|
|
while (stringLength < length)
|
|
{
|
|
sb.Append(filler);
|
|
stringLength++;
|
|
}
|
|
return sb.ToString() + str;
|
|
}
|
|
public static String RemoveHtml(String strItem)
|
|
{
|
|
String[] codes = { "'","»" };
|
|
if(null==strItem)return strItem;
|
|
foreach (String code in codes)
|
|
{
|
|
strItem = strItem.Replace(code,"'");
|
|
}
|
|
return strItem;
|
|
// String str=strItem.Replace("'","'");
|
|
// return str;
|
|
}
|
|
public static String RemoveDivs(String strItem)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
bool inDiv=false;
|
|
if(null==strItem)return strItem;
|
|
for(int index=0;index<strItem.Length;index++)
|
|
{
|
|
char ch=strItem[index];
|
|
if(ch.Equals('<'))inDiv=true;
|
|
else if(ch.Equals('>'))inDiv=false;
|
|
else if(!inDiv)sb.Append(ch);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static String BetweenString(String strItem, String strBegin, String strEnd)
|
|
{
|
|
if (null == strItem) return null;
|
|
int index=-1;
|
|
if(null==strBegin)index=0;
|
|
else index = strItem.IndexOf(strBegin);
|
|
if (-1 == index) return null;
|
|
String str = null;
|
|
if(null!=strBegin)str=strItem.Substring(index + strBegin.Length);
|
|
else str=strItem;
|
|
if(null==strEnd)return str;
|
|
index = str.IndexOf(strEnd);
|
|
if (-1 == index) return null;
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int strIndex = 0; strIndex < str.Length; strIndex++)
|
|
{
|
|
if (index == strIndex) break;
|
|
sb.Append(str[strIndex]);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static String RemoveAfter(String strItem, char charItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int index = 0; index < strItem.Length; index++)
|
|
{
|
|
char ch = strItem[index];
|
|
if (ch.Equals(charItem)) break;
|
|
sb.Append(ch);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static bool OutOfRange(double value)
|
|
{
|
|
return value > 100000000000000000000.00 || value< -99999999999999999999.99;
|
|
}
|
|
public static String RemoveControlChars(String strItem)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
for(int index=0;index<strItem.Length;index++)
|
|
{
|
|
char ch=strItem[index];
|
|
if(!char.IsControl(ch))sb.Append(ch);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static String GetPath(String strPathFileName)
|
|
{
|
|
int index=strPathFileName.LastIndexOf('\\');
|
|
if (-1 == index) return null;
|
|
String strPath = strPathFileName.Substring(0, index);
|
|
return strPath;
|
|
}
|
|
public static String KeepBefore(String strItem,String strKeepBefore)
|
|
{
|
|
int startPos=strItem.IndexOf(strKeepBefore);
|
|
if(-1==startPos)return null;
|
|
return strItem.Substring(0,startPos);
|
|
}
|
|
public static String KeepAfter(String strItem,String strKeepAfter)
|
|
{
|
|
int startPos=strItem.IndexOf(strKeepAfter);
|
|
if(-1==startPos)return null;
|
|
return strItem.Substring(startPos+strKeepAfter.Length);
|
|
}
|
|
public static String KeepAfterLast(String strItem,String strKeepAfter)
|
|
{
|
|
if(null==strItem)return null;
|
|
int startPos=strItem.LastIndexOf(strKeepAfter);
|
|
if(-1==startPos)return null;
|
|
return strItem.Substring(startPos+strKeepAfter.Length);
|
|
}
|
|
public static String Find(String strItem,String search,char delimeter)
|
|
{
|
|
if(null==strItem)return null;
|
|
bool foundDelimeter=false;
|
|
StringBuilder sb=new StringBuilder();
|
|
int startPos=strItem.LastIndexOf(search);
|
|
if(-1==startPos)return null;
|
|
startPos+=search.Length;
|
|
for(;startPos<strItem.Length;startPos++)
|
|
{
|
|
char ch=strItem[startPos];
|
|
if(ch.Equals(delimeter))
|
|
{
|
|
foundDelimeter=true;
|
|
break;
|
|
}
|
|
sb.Append(ch);
|
|
}
|
|
if(!foundDelimeter)return null;
|
|
return sb.ToString();
|
|
}
|
|
public static String FindFirst(String strItem,String search,char delimeter)
|
|
{
|
|
if(null==strItem)return null;
|
|
bool foundDelimeter=false;
|
|
StringBuilder sb=new StringBuilder();
|
|
int startPos=strItem.IndexOf(search);
|
|
if(-1==startPos)return null;
|
|
startPos+=search.Length;
|
|
for(;startPos<strItem.Length;startPos++)
|
|
{
|
|
char ch=strItem[startPos];
|
|
if(ch.Equals(delimeter))
|
|
{
|
|
foundDelimeter=true;
|
|
break;
|
|
}
|
|
sb.Append(ch);
|
|
}
|
|
if(!foundDelimeter)return null;
|
|
return sb.ToString();
|
|
}
|
|
public static String AddQuotes(String item)
|
|
{
|
|
return "\"" + item + "\"";
|
|
}
|
|
public static long DateToLong(DateTime date)
|
|
{
|
|
int year = date.Year;
|
|
int month = date.Month;
|
|
int day = date.Day;
|
|
return (year * 10000) + (month * 100) + day;
|
|
}
|
|
public static DateTime LongToDate(long longDate)
|
|
{
|
|
int year = (int)(longDate / 10000);
|
|
int month = ((int)longDate / 100) - year * 100;
|
|
int day = (int)(longDate - ((int)(longDate / 100)) * 100);
|
|
return new DateTime(year, month, day);
|
|
}
|
|
public static String DateTimeToStringHHMMSS(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("HH:mm:ss");
|
|
}
|
|
public static String DateTimeToStringMMSDDSYYYY(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("MM/dd/yyyy");
|
|
}
|
|
public static String DateTimeToStringMMSYYYY(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("MM/yyyy");
|
|
}
|
|
public static String DateTimeToStringMMSYY(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("MM/yy");
|
|
}
|
|
public static String DateTimeToStringMMSDDSYYYYHHMMSS(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("MM/dd/yyyy hh:mm:ss");
|
|
}
|
|
public static String DateTimeToStringMMHDDHYYYY(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("MM-dd-yyyy");
|
|
}
|
|
public static String DateTimeToStringYYYYHMMHDD(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("yyyy-MM-dd");
|
|
}
|
|
public static String DateTimeToStringYYYYHMMHDDHHMMSS(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("yyyy-MM-dd HH:MM:ss");
|
|
}
|
|
public static String DateTimeToStringYYYYMMDD(DateTime dateTime)
|
|
{
|
|
if (Utility.IsEpoch(dateTime)) return "";
|
|
return dateTime.ToString("yyyyMMdd");
|
|
}
|
|
public static String AsteriskForString(String str)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
int length = str.Length;
|
|
for (int index = 0; index < length; index++) sb.Append("*");
|
|
return sb.ToString();
|
|
}
|
|
public static String FormatNumber(double number)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
if (double.NaN.Equals(number))sb.Append("N/A");
|
|
else sb.Append(String.Format("{0:0.000}", number));
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static String FormatNumberConstrain(double value,int places=1,bool commas=false)
|
|
{
|
|
String strValue=null;
|
|
if(value>=1000000000000)
|
|
{
|
|
value/=1000000000000;
|
|
strValue=Utility.FormatNumber(value,places,commas)+"T";
|
|
}
|
|
else if(value>=1000000000)
|
|
{
|
|
value/=1000000000;
|
|
strValue=Utility.FormatNumber(value,places,commas)+"B";
|
|
}
|
|
else if(value>=1000000)
|
|
{
|
|
value/=1000000;
|
|
strValue=Utility.FormatNumber(value,places,commas)+"M";
|
|
}
|
|
else if(value>=1000)
|
|
{
|
|
value/=1000;
|
|
strValue=Utility.FormatNumber(value,places,commas)+"K";
|
|
}
|
|
else
|
|
{
|
|
strValue=Utility.FormatNumber(value,places,commas);
|
|
}
|
|
return strValue;
|
|
}
|
|
public static String FormatNumber(double number,int places,bool commas=false)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
StringBuilder formatString=new StringBuilder();
|
|
if (commas&&number>=1000.00) formatString.Append("{0:0,0.");
|
|
else formatString.Append("{0:0.");
|
|
for(int index=0;index<places;index++)formatString.Append("0");
|
|
formatString.Append("}");
|
|
if (double.NaN.Equals(number)) sb.Append("N/A");
|
|
else sb.Append(String.Format(formatString.ToString(), number));
|
|
return sb.ToString();
|
|
}
|
|
public static String FormatCurrency(double number)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
if (double.NaN.Equals(number))sb.Append("N/A");
|
|
else sb.Append(String.Format("{0:C}", number));
|
|
return sb.ToString();
|
|
}
|
|
public static String FormatCurrency(double number,int decimals)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
String currencyFormat="{0:C"+decimals+"}";
|
|
if (double.NaN.Equals(number))sb.Append("N/A");
|
|
else sb.Append(String.Format(currencyFormat, number));
|
|
return sb.ToString();
|
|
}
|
|
public static String FormatPercent(double number)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (double.NaN.Equals(number)) sb.Append("N/A");
|
|
else sb.Append(String.Format("{0:P}", number));
|
|
return sb.ToString();
|
|
}
|
|
public static String ConformDate(String strDate)
|
|
{
|
|
String[] elements=strDate.Split(' ');
|
|
if(elements.Length<3)return strDate;
|
|
return elements[0]+" "+elements[1]+" "+elements[2];
|
|
}
|
|
public static DateTime ParseDate(String strDate)
|
|
{
|
|
System.Globalization.CultureInfo cultureInfo = new System.Globalization.CultureInfo("en-US");
|
|
String[] formats = new[] {"dddd, MMMM dd","MMM dd yyyy","yyyy-MM","ddd, MMM. d","ddd, MMM. dd", "yyyy/MM/dd","M-d-yyyy", "dd-MM-yyyy", "MM-dd-yyyy", "M.d.yyyy", "dd.MM.yyyy", "MM.dd.yyyy","yyyyMMdd" }.Union(cultureInfo.DateTimeFormat.GetAllDateTimePatterns()).ToArray();
|
|
strDate = strDate.Trim();
|
|
DateTime dateTime=DateTime.ParseExact(strDate, formats, new System.Globalization.CultureInfo("en-US"), DateTimeStyles.AssumeLocal);
|
|
return dateTime;
|
|
}
|
|
public static double ParsePercent(String strPercent)
|
|
{
|
|
if (null == strPercent) return double.NaN;
|
|
strPercent = strPercent.Replace("%", null);
|
|
try { return double.Parse(strPercent)/100.00; }
|
|
catch (Exception) { return double.NaN; }
|
|
}
|
|
public static double ParseCurrency(String strNumber)
|
|
{
|
|
if (null == strNumber) return double.NaN;
|
|
if(Constants.CONST_DASHES.Equals(strNumber))return double.NaN;
|
|
strNumber = strNumber.Replace("$", null);
|
|
strNumber = strNumber.Replace(",", null);
|
|
strNumber = strNumber.Replace("(", "-");
|
|
strNumber = strNumber.Replace(")", null);
|
|
if (strNumber.Equals("")) return double.NaN;
|
|
try { return double.Parse(strNumber); }
|
|
catch (Exception) { return double.NaN; }
|
|
}
|
|
public static String FormatCurrencyWithQuotes(double number)
|
|
{
|
|
return AddQuotes(FormatCurrency(number));
|
|
}
|
|
public static String FormatDates(DateTime d1, DateTime d2)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
sb.Append(Utility.DateTimeToStringMMSDDSYYYY(d1)).Append("-");
|
|
sb.Append(Utility.DateTimeToStringMMSDDSYYYY(d2));
|
|
return sb.ToString();
|
|
}
|
|
public static String TrimToSpace(String strString)
|
|
{
|
|
if (null == strString) return strString;
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int index = 0; index < strString.Length; index++)
|
|
{
|
|
char ch=strString[index];
|
|
if (' '.Equals(ch)) break;
|
|
sb.Append(ch);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static String BooleanToYesNoString(bool booleanValue)
|
|
{
|
|
return booleanValue ? "Yes" : "No";
|
|
}
|
|
public static bool IsEpoch(DateTime dateTime)
|
|
{
|
|
return dateTime.Equals(epoch);
|
|
}
|
|
public static DateTime Epoch
|
|
{
|
|
get { return epoch; }
|
|
}
|
|
public static TimeSpan OneDay
|
|
{
|
|
get{return oneDay;}
|
|
}
|
|
public static String ListToString(List<String> list,char separator=',')
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
if (null == list || 0 == list.Count) return null;
|
|
for(int index=0;index<list.Count;index++)
|
|
{
|
|
sb.Append(list[index]);
|
|
if(index<list.Count-1)sb.Append(separator);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static List<String> ToList(String items,char separator=',')
|
|
{
|
|
List<String> list = items.Split(separator).ToList<String>();
|
|
list=(from String s in list select s.Trim()).ToList<String>();
|
|
return list;
|
|
}
|
|
public static String FromList(List<String> items,String postFix=",")
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
for(int index=0;index<items.Count;index++)
|
|
{
|
|
sb.Append(items[index]);
|
|
if(index<items.Count-1)sb.Append(postFix);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public static byte[] Compress(String strString)
|
|
{
|
|
MemoryStream outputStream = null;
|
|
GZipStream compressionStream = null;
|
|
try
|
|
{
|
|
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(strString);
|
|
outputStream = new MemoryStream();
|
|
compressionStream = new GZipStream(outputStream, CompressionMode.Compress, true);
|
|
compressionStream.Write(bytes, 0, bytes.Length);
|
|
compressionStream.Close();
|
|
compressionStream = null;
|
|
byte[] outputBytes = outputStream.ToArray();
|
|
outputStream.Close();
|
|
outputStream = null;
|
|
return outputBytes;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,exception);
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
if (null != compressionStream)
|
|
{
|
|
compressionStream.Close();
|
|
compressionStream = null;
|
|
}
|
|
if (null != outputStream)
|
|
{
|
|
outputStream.Close();
|
|
outputStream = null;
|
|
}
|
|
}
|
|
}
|
|
public static String Decompress(byte[] compressedBytes)
|
|
{
|
|
MemoryStream compressedStream = new MemoryStream(compressedBytes);
|
|
GZipStream decompressionStream = new GZipStream(compressedStream, CompressionMode.Decompress,true);
|
|
MemoryStream outputStream=new MemoryStream();
|
|
try
|
|
{
|
|
byte[] decompressedBytesBuffer = new byte[4096];
|
|
int count = 0;
|
|
while (true)
|
|
{
|
|
count = decompressionStream.Read(decompressedBytesBuffer, 0, decompressedBytesBuffer.Length);
|
|
if (count > 0) outputStream.Write(decompressedBytesBuffer, 0, count);
|
|
else break;
|
|
}
|
|
decompressionStream.Close();
|
|
compressedStream.Close();
|
|
String strDecompressed = System.Text.Encoding.UTF8.GetString(outputStream.ToArray());
|
|
outputStream.Close();
|
|
outputStream = null;
|
|
compressedStream = null;
|
|
decompressionStream = null;
|
|
return strDecompressed;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,exception);
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
if (null != outputStream)
|
|
{
|
|
outputStream.Close();
|
|
outputStream = null;
|
|
}
|
|
if (null != decompressionStream)
|
|
{
|
|
decompressionStream.Close();
|
|
decompressionStream = null;
|
|
}
|
|
if (null != compressedStream)
|
|
{
|
|
compressedStream.Close();
|
|
compressedStream = null;
|
|
}
|
|
}
|
|
}
|
|
public static void LaunchBrowserSearch(String searchTerm)
|
|
{
|
|
Process.Start("https://www.google.com/search?q="+Uri.EscapeDataString(searchTerm)+"/");
|
|
// OpenWebCommand = new Command(async () => await Browser.OpenAsync("https://www.google.com"));
|
|
}
|
|
public static bool IsZeroOrNaN(double value)
|
|
{
|
|
return IsNaN(value)||IsZero(value);
|
|
}
|
|
private static bool IsZero(double value)
|
|
{
|
|
if(value==0.00)return true;
|
|
return false;
|
|
}
|
|
private static bool IsNaN(double value)
|
|
{
|
|
return double.IsNaN(value);
|
|
}
|
|
public static void DeleteFile(String pathFileName)
|
|
{
|
|
if(!File.Exists(pathFileName))return;
|
|
try{File.Delete(pathFileName);}catch(Exception){;}
|
|
}
|
|
private static DateTime GetRunDate(String strPathFileName)
|
|
{
|
|
DateTime runDate=DateTime.Now.Date;
|
|
DateGenerator dateGenerator=new DateGenerator();
|
|
StreamWriter streamWriter=null;
|
|
StreamReader streamReader=null;
|
|
|
|
try
|
|
{
|
|
if(!File.Exists(strPathFileName))
|
|
{
|
|
streamWriter=File.CreateText(strPathFileName);
|
|
streamWriter.WriteLine(Utility.DateTimeToStringMMHDDHYYYY(runDate));
|
|
streamWriter.Flush();
|
|
streamWriter.Close();
|
|
streamWriter=null;
|
|
return runDate;
|
|
}
|
|
streamReader=File.OpenText(strPathFileName);
|
|
String strLine=streamReader.ReadLine();
|
|
streamReader.Close();
|
|
streamReader=null;
|
|
runDate=Utility.ParseDate(strLine);
|
|
if(dateGenerator.DaysBetweenActual(runDate,DateTime.Now)>5)
|
|
{
|
|
File.Delete(strPathFileName);
|
|
runDate=DateTime.Now.Date;
|
|
streamWriter=File.CreateText(strPathFileName);
|
|
streamWriter.WriteLine(Utility.DateTimeToStringMMHDDHYYYY(runDate));
|
|
streamWriter.Flush();
|
|
streamWriter.Close();
|
|
streamWriter=null;
|
|
return runDate;
|
|
}
|
|
return runDate;
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("GetRunDate:{0}",exception.ToString()));
|
|
return runDate;
|
|
}
|
|
finally
|
|
{
|
|
if(null!=streamWriter)streamWriter.Close();
|
|
if(null!=streamReader)streamReader.Close();
|
|
}
|
|
}
|
|
}
|
|
} |