public void ConvertToMetaStock(PSEDocument pseDocument, MetaOutputSettings metaOutputSettings)
{
if (OnConvertComplete != null)
{
OnConvertComplete(pseDocument, new ConvertEventArgs(metaOutputSettings));
}
}
public void TestMiscData()
{
IPdfService pdfService = new PdfTextSharpService();
var pseDocument = new PSEDocument();
IPSEReportReader reader = new PSEReportReader2();
reader.Fill(pseDocument, pdfService.ExtractTextFromPdf(_reportFile));
//NO.OF ADVANCES: 114
//NO.OF DECLINES: 79
//NO.OF UNCHANGED: 42
//NO.OF TRADED ISSUES: 235
//NO.OF TRADES: 92,699
//ODDLOT VOLUME: 791,591
//ODDLOT VALUE: Php 267,667.16
//BLOCK SALE VOLUME: 248,879,170
//BLOCK SALE VALUE: Php 3,836,846,796.68
var expected = 0.0;
var actual = 0.0;
expected = 114;
actual = pseDocument.NumAdvance;
Assert.AreEqual(expected, actual, "Advances does not match.");
expected = 79;
actual = pseDocument.NumDeclines;
Assert.AreEqual(expected, actual, "Declines does not match.");
expected = 42;
actual = pseDocument.NumUnchanged;
Assert.AreEqual(expected, actual, "Unchanged does not match.");
}
public static void DownloadAndConvertAsync(DownloadAndConvertParams downloadAndConvertParams)
{
var param = new DownloadParams();
document = null;
param.BaseURL = downloadAndConvertParams.DownloadUri.ToString();
param.FileName = "stockQuotes_%mm%dd%yyyy";
param.FromDate = downloadAndConvertParams.FromDate;
param.ToDate = downloadAndConvertParams.ToDate;
DownloadAndConvertHelper._outputSettings = downloadAndConvertParams.OutputSettings;
ConvertCompleteCallback = downloadAndConvertParams.ConvertCompleteCallback;
BeforeConvertCallback = downloadAndConvertParams.BeforeConvertCallback;
ProcessCompletedCallback = downloadAndConvertParams.ProcessCompletedCallback;
ConvertErrorHandler = downloadAndConvertParams.ConvertErrorHandler;
var downloader = new ReportDownloader(param, downloadAndConvertParams.SavePath, ProcessDownloadedFile);
downloader.OnReportDownloadCompletedEvent += downloadAndConvertParams.ReportDownloadedHandler;
downloader.OnDownloadAllCompletedEvent += downloadAndConvertParams.DownloadAllCompletedHandler;
downloader.OnDownloadAllCompletedEvent += (s, e) => {
downloadAndConvertParams.ProcessCompletedCallback(document);
};
downloader.OnStartDownloadProcess += downloadAndConvertParams.OnStartDownloadProcess;
downloader.OnDownloadProgressEvent += downloadAndConvertParams.DownloadProgressHandler;
downloader.Download();
}
//private static OutputSettings _outputSettings;
public static PSEDocument LoadFromReportFile(string fullFilePath, OutputSettings outputSettings)
{
//var doc = PDDocument.load(fullFilePath);
////PSEDocument pd = new PSEDocument();
//var stripper = new PDFTextStripper();
//string pdfText = stripper.getText(doc).TrimEnd();
IPdfService pdfService = ServiceLocator.Current.GetInstance <IPdfService>();
string pdfText = pdfService.ExtractTextFromPdf(fullFilePath);
var document = new PSEDocument();
var reader = new PSEReportReader2();
reader.Fill(document, pdfText);
if (outputSettings is CSVOutputSettings)
{
(outputSettings as CSVOutputSettings).Filename = Path.GetFileNameWithoutExtension(fullFilePath) + ".csv";
document.ToCSV(outputSettings as CSVOutputSettings);
}
if (outputSettings is AmiOutputSettings)
{
document.ToAmibroker(outputSettings as AmiOutputSettings);
}
if (outputSettings is MetaOutputSettings)
{
document.ToMetaStock(outputSettings as MetaOutputSettings);
}
return(document);
}
private void SetAmibrokerData(IOperationInvoker amiInvoker, PSEDocument pseDocument,
StockBase stockData, AmiOutputSettings amiOutputSettings)
{
int version = Convert.ToInt32(amiInvoker.Property("Version").Get <string>().Replace(".", string.Empty));
// stocks collection
IOperationInvoker stocks = amiInvoker.Property("Stocks").Get <IOperationInvoker>();
// add stock item to collection
IOperationInvoker stock = stocks.Method("Add").AddParameter(stockData.Symbol).Invoke <IOperationInvoker>();
// quotations collection
IOperationInvoker quotations = stock.Property("Quotations").Get <IOperationInvoker>();
// add a quoatation item to collection
IOperationInvoker quotation = quotations.Method("Add").AddParameter(pseDocument.TradeDate).Invoke <IOperationInvoker>();
if (version >= 5400)
{
// new 5.4 and up properties
stock.Property("FullName").Set(stockData.Description);
}
quotation.Property("Open").Set(stockData.Open);
quotation.Property("High").Set(stockData.High);
quotation.Property("Low").Set(stockData.Low);
quotation.Property("Close").Set(stockData.Close);
if (stockData.Symbol.StartsWith("^"))
{
double volume;
double nfb;
if (amiOutputSettings.UseSectorValueAsVolume)
{
volume = Math.Truncate(stockData.Value) / amiOutputSettings.SectorVolumeDivider;
}
else
{
volume = stockData.Volume / amiOutputSettings.SectorVolumeDivider;
}
if (stockData.Symbol == "^PSEi")
{
nfb = pseDocument.NetForeignBuying / amiOutputSettings.SectorVolumeDivider;
}
else
{
nfb = stockData.NetForeignBuy / amiOutputSettings.SectorVolumeDivider;
}
quotation.Property("Volume").Set(Math.Truncate(volume));
quotation.Property("OpenInt").Set(Math.Truncate(nfb));
}
else
{
quotation.Property("Volume").Set(stockData.Volume);
quotation.Property("OpenInt").Set(stockData.NetForeignBuy);
}
}
public void ConvertToCSV(PSEDocument pseDocument, CSVOutputSettings csvOutputSettings)
{
//Debug.WriteLine(csvOutputSettings.ToString());
List <string> csvOutput = new List <string>();
string tradeDate = pseDocument.TradeDate.ToString(csvOutputSettings.DateFormat);
string csvFormat = csvOutputSettings.CSVFormat.Replace(CSVOutputSettings.DATE_SYMBOL, tradeDate);
csvFormat = csvFormat.Replace(",", csvOutputSettings.Delimiter);
foreach (SectorItem sectorItem in pseDocument.Sectors)
{
// sectors
//sectorItem.Volume = sectorItem.Volume / csvOutputSettings.SectorVolumeDivider;
sectorItem.Value = Math.Truncate(sectorItem.Value / csvOutputSettings.SectorVolumeDivider);
//sectorItem.NetForeignBuy = Math.Truncate(sectorItem.NetForeignBuy / csvOutputSettings.SectorVolumeDivider);
csvOutput.Add(getCSVLine(csvFormat, sectorItem, csvOutputSettings));
//sub sectors
foreach (SubSectorItem subsectorItem in sectorItem.SubSectors)
{
// stocks
foreach (StockItem stockItem in subsectorItem.Stocks)
{
if (stockItem.Open > 0)
{
csvOutput.Add(getCSVLine(csvFormat, stockItem, csvOutputSettings));
}
}
}
}
// write to file
string filename = csvOutputSettings.OutputDirectory + Helpers.GetDirectorySeparator() +
csvOutputSettings.Filename;
using (StreamWriter writer = new StreamWriter(filename))
{
try
{
foreach (string item in csvOutput)
{
writer.WriteLine(item);
}
}
finally
{
writer.Flush();
writer.Close();
}
};
if (OnConvertComplete != null)
{
OnConvertComplete(pseDocument, new ConvertEventArgs(csvOutputSettings));
}
}
public void TestSectorStockCount()
{
IPdfService pdfService = new PdfTextSharpService();
var pseDocument = new PSEDocument();
IPSEReportReader reader = new PSEReportReader2();
reader.Fill(pseDocument, pdfService.ExtractTextFromPdf(_reportFile));
var finance = pseDocument.GetSector(PSEDocument.FINANCIAL);
var expected = 0;
var actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.FINANCIAL + " sector stock count fail.");
var industrial = pseDocument.GetSector(PSEDocument.INDUSTRIAL);
expected = 0;
actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.INDUSTRIAL + " sector stock count fail.");
var property = pseDocument.GetSector(PSEDocument.PROPERTY);
expected = 0;
actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.PROPERTY + " sector stock count fail.");
var services = pseDocument.GetSector(PSEDocument.SERVICE);
expected = 0;
actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.SERVICE + " sector stock count fail.");
var mining = pseDocument.GetSector(PSEDocument.MINING_OIL);
expected = 0;
Assert.AreEqual(expected, actual, PSEDocument.MINING_OIL + " sector stock count fail.");
var preferred = pseDocument.GetSector(PSEDocument.PREFERRED);
expected = 0;
actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.PREFERRED + " sector stock count fail.");
var warrants = pseDocument.GetSector(PSEDocument.WARRANT);
expected = 0;
actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.WARRANT + " sector stock count fail.");
var sme = pseDocument.GetSector(PSEDocument.SME);
expected = 0;
actual = 0;
Assert.AreEqual(expected, actual, PSEDocument.SME + " sector stock count fail.");
}
public void Execute(PSEDocument pseDocument, MetaOutputSettings outputSettings)
{
string asc2msPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\asc2ms.exe";
string convertParam = getConvertParams();
Process p = new Process();
ProcessStartInfo startInfo = new ProcessStartInfo(asc2msPath, convertParam);
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;
p.StartInfo = startInfo;
p.Start();
}
/// <summary>
/// parse this._pseReportString and fill PSEDocument Collection
/// </summary>
/// <param name="pseDocument"></param>
public void Fill(PSEDocument pseDocument)
{
_tradeDate = this.getTradeDate();
pseDocument.TradeDate = _tradeDate;
InitializeSectorMapping();
this.Cleanup();
ParseReportBody(pseDocument);
ParseReportMisc(pseDocument);
ParseSectorSummary(pseDocument);
pseDocument.ExchangeNotice = reportNotice;
}
public void TestReaderFill_TradDate()
{
var stripper = new PDFTextStripper();
var reader = new PSEReportReader(stripper.getText(doc).TrimEnd());
var pd = new PSEDocument();
reader.Fill(pd);
DateTime expected = DateTime.Parse("11/06/2013");
DateTime actual = pd.TradeDate;
Assert.AreEqual(expected, actual);
}
private void DoConvertFromFiles()
{
SetOutputSettings();
IEnumerable <string> fileList = getSelectedFiles();
//MonoPSEGetDataService dataService = new MonoPSEGetDataService();
foreach (string s in fileList)
{
labelStatus.Text = "Converting " + s;
PSEDocument pseDocument = Helpers.ConvertReportFile(s, this.csvOutputSettings);
//dataService.SaveTradeData(pseDocument);
}
labelStatus.Text = "Done.";
// Thread t = new Thread(ConvertFromFileHelper.ConvertFromFiles);
// ConvertFromFilesParam param = new ConvertFromFilesParam();
// param.FileList = getSelectedFiles();
// param.OutputSettings = this.csvOutputSettings;
// param.threadObject = t;
// param.OnStartProcess = () =>
// {
// //labelStatus.Text = "Initializing...";
// };
//
// param.BeforeConvertCallback = (reportFileName) =>
// {
// // send stuff to progress
// //labelStatus.Text = "Converting " + reportFileName;
// };
//
// param.ProgressCallback = (reportFilename, pseDocument) =>
// {
// MonoPSEGetDataService dataService = new MonoPSEGetDataService();
// dataService.SaveTradeData(pseDocument);
//
// };
//
// param.ExceptionCallback = (e) =>
// {
//
// };
//
// param.CompletedCallback = (pseDocument) =>
// {
// //labelStatus.Text = "Done.";
// };
//
// t.Start(param);
}
public void TestUnsupportedReportFormat(string fileToConvert)
{
IPdfService pdfService = new PdfTextSharpService();
var pseDocument = new PSEDocument();
IPSEReportReader reader = new PSEReportReader2();
Assert.Throws(
typeof(EUnsupportedReportFormat),
new TestDelegate(() =>
{
reader.Fill(pseDocument, pdfService.ExtractTextFromPdf(fileToConvert));
}),
"An exception wasn't thrown");
}
public void TestReaderFill_TradDate()
{
//PDFTextStripper stripper = new PDFTextStripper();
var pdfSharpService = new PdfTextSharpService();
var reader = new PSEReportReader2();
PSEDocument pd = new PSEDocument();
reader.Fill(pd, pdfSharpService.ExtractTextFromPdf(pdfDocPath));
DateTime expected = DateTime.Parse("05/05/2016");
DateTime actual = pd.TradeDate;
Assert.AreEqual(expected, actual);
}
public void TestMarketSummary_PSEi()
{
IPdfService pdfService = new PdfTextSharpService();
var pseDocument = new PSEDocument();
IPSEReportReader reader = new PSEReportReader2();
reader.Fill(pseDocument, pdfService.ExtractTextFromPdf(_reportFile));
//OPEN HIGH LOW CLOSE %CHANGE PT.CHANGE VOLUME VALUE, Php
//PSEi 7,363.88 7,456.26 7,354.57 7,446.49 1.42 104.84
//All Shares 4,424.05 4,464.21 4,420.44 4,460.56 1.06 47.14
//GRAND TOTAL 1,949,153,231 11,941,051,832.83
var expected = 0.0;
var actual = 0.0;
//psei
var psei = pseDocument.GetSector(PSEDocument.PSEI);
expected = 7363.88;
actual = psei.Open;
Assert.AreEqual(expected, actual, "PSEi open does not match");
expected = 7456.26;
actual = psei.High;
Assert.AreEqual(expected, actual, "PSEi high does not match");
expected = 7354.57;
actual = psei.Low;
Assert.AreEqual(expected, actual, "PSEi low does not match");
expected = 7446.49;
actual = psei.Close;
Assert.AreEqual(expected, actual, "PSEi close does not match");
expected = 1949153231.0;
actual = psei.Volume;
Assert.AreEqual(expected, actual, "PSEi Volume does not match");
expected = 4076175042.08;
actual = psei.NetForeignBuy;
Assert.AreEqual(expected, actual, "PSEi NFB does not match");
//all shares
}
private static void ProcessDownloadedFile(object sender, AsyncCompletedEventArgs e)
{
ReportDownloader downloader = sender as ReportDownloader;
if (e.Error != null)
{
if (downloader.CurrentDownloadFile != null)
{
File.Delete(downloader.CurrentDownloadFile);
}
}
else
{
// convert the downloaded files
//foreach (var downloadedFile in downloader.DownloadedFiles)
//for (int i = 0; i < downloader.DownloadedFiles.Count; i++)
//{
if (downloader.DownloadedFiles.Count == 0)
{
return;
}
var downloadedFile = (from x in downloader.DownloadedFiles
where x.Filename == downloader.CurrentDownloadFile
select x).First(); //DownloadedFiles[i];
try
{
if (downloadedFile == null)
{
throw new Exception("Unable to find file to convert.");
}
BeforeConvertCallback(downloadedFile.Filename);
document = Helpers.LoadFromReportFile(downloadedFile.Filename, DownloadAndConvertHelper._outputSettings);
downloadedFile.Converted = true;
ConvertCompleteCallback(downloader, document);
}
catch (Exception ex)
{
downloadedFile.Converted = false;
ConvertErrorHandler(downloader, ex);
}
//}
}
}
public void TestMarketSummary_Financials()
{
IPdfService pdfService = new PdfTextSharpService();
var pseDocument = new PSEDocument();
IPSEReportReader reader = new PSEReportReader2();
reader.Fill(pseDocument, pdfService.ExtractTextFromPdf(_reportFile));
//OPEN HIGH LOW CLOSE %CHANGE PT.CHANGE VOLUME VALUE, Php
//Financials 1,835.16 1,865.93 1,830.89 1,865.93 1.7 31.31 15,721,945 1,537,689,244.77
//GRAND TOTAL 1,949,153,231 11,941,051,832.83
var expected = 0.0;
var actual = 0.0;
//psei
var psei = pseDocument.GetSector(PSEDocument.FINANCIAL);
expected = 1835.16;
actual = psei.Open;
Assert.AreEqual(expected, actual, "FINANCIAL open does not match");
expected = 1865.93;
actual = psei.High;
Assert.AreEqual(expected, actual, "FINANCIAL high does not match");
expected = 1830.89;
actual = psei.Low;
Assert.AreEqual(expected, actual, "FINANCIAL low does not match");
expected = 1865.93;
actual = psei.Close;
Assert.AreEqual(expected, actual, "FINANCIAL close does not match");
expected = 15721945.0;
actual = psei.Volume;
Assert.AreEqual(expected, actual, "FINANCIAL Volume does not match");
expected = 1537689244.77;
actual = psei.Value;
Assert.AreEqual(expected, actual, "FINANCIAL Value does not match");
//all shares
}
private void InsertMiscData(PSEDocument pseDocument)
{
string sql = "INSERT INTO MISCTAB VALUES(NULL, @TRADEDATE, @ADVANCE, @DECLINE, @UNCHANGED, @TRADEDISSUES, @NUMTRADES, @FOREIGNBUY, @FOREIGNSELL, @CROSSVOLUME, @CROSSVALUE, @BLOCKSALES)";
SqliteCommand cmd = new SqliteCommand(sql, DbConnection, DbTransaction);
cmd.Parameters.Add("@TRADEDATE", DbType.String).Value = pseDocument.TradeDate.ToString("yyyy-MM-dd");
cmd.Parameters.Add("@ADVANCE", DbType.Int32).Value = pseDocument.NumAdvance;
cmd.Parameters.Add("@DECLINE", DbType.Int32).Value = pseDocument.NumDeclines;
cmd.Parameters.Add("@UNCHANGED", DbType.Int32).Value = pseDocument.NumUnchanged;
cmd.Parameters.Add("@TRADEDISSUES", DbType.Int32).Value = pseDocument.NumTraded;
cmd.Parameters.Add("@NUMTRADES", DbType.Int32).Value = pseDocument.NumTrades;
cmd.Parameters.Add("@FOREIGNBUY", DbType.UInt64).Value = Math.Truncate(pseDocument.TotalForeignBuying);
cmd.Parameters.Add("@FOREIGNSELL", DbType.UInt64).Value = Math.Truncate(pseDocument.TotalForeignSelling);
cmd.Parameters.Add("@CROSSVOLUME", DbType.UInt64).Value = pseDocument.MainCrossVolume;
cmd.Parameters.Add("@CROSSVALUE", DbType.UInt64).Value = Math.Truncate(pseDocument.MainCrossValue);
cmd.Parameters.Add("@BLOCKSALES", DbType.String).Value = pseDocument.BlockSales;
cmd.ExecuteNonQuery();
}
public void Fill(PSEDocument pseDocument, string pseReportFile)
{
_reportString = pseReportFile;
_pseDocument = pseDocument;
InitSectors();
pseDocument.TradeDate = GetTradeDate();
if (pseDocument.TradeDate.CompareTo(new DateTime(2017, 4, 4)) < 0)
{
throw new EUnsupportedReportFormat("Unsupported report format. Quotation reports prior to April 6, 2017 are not supported.");
}
CleanupReportString();
ParseReportBody();
ParseSectorSummary();
ParseForeignTransaction();
ParseReportMisc();
}
private void ShowExchangeNotice(PSEDocument pseDocument)
{
if (pseDocument != null)
{
ShowCloseProgressDialogDelegate showMarketSummaryTab = () =>
{
Messenger.Default.Send(
new ShowMarketSummaryMessage {
TradeDate = pseDocument.TradeDate
});
Messenger.Default.Send(
new ShowExchangeNoticeMessage {
NoticeText = pseDocument.ExchangeNotice
}
);
};
Application.Current.Dispatcher.Invoke(showMarketSummaryTab, null);
}
}
public void Execute(PSEDocument pseDocument)
{
pseiValue = (from q in pseDocument.Sectors
where q.Symbol == "^PSEi"
select q).FirstOrDefault().Value;
this.DbConnection.Open();
try
{
this.DbTransaction = DbConnection.BeginTransaction();
try
{
this.DeleteTradeData(pseDocument.TradeDate);
foreach (SectorItem sectorItem in pseDocument.Sectors)
{
this.DoDbInsert(sectorItem);
foreach (SubSectorItem subSectorItem in sectorItem.SubSectors)
{
foreach (StockItem stockItem in subSectorItem.Stocks)
{
this.DoDbInsert(stockItem);
}
}
}
this.InsertMiscData(pseDocument);
this.DbTransaction.Commit();
}
catch
{
this.DbTransaction.Rollback();
throw;
}
}
finally
{
this.DbConnection.Close();
}
}
static void ConvertIt(string fileToConvert)
{
IPdfService pdfService = new PdfTextSharpService();
var pseDocument = new PSEDocument();
IPSEReportReader reader = new PSEReportReader2();
reader.Fill(pseDocument, pdfService.ExtractTextFromPdf(fileToConvert));
if (_outputFormat.Contains("csv"))
{
string[] csvParam = _outputFormat.Split(':');
string csvFormat = string.Empty;
if (csvParam.Length == 2)
{
csvFormat = csvParam[1];
csvFormat = csvFormat.Replace("S", "{S}");
csvFormat = csvFormat.Replace("D", "{D}");
csvFormat = csvFormat.Replace("O", "{O}");
csvFormat = csvFormat.Replace("H", "{H}");
csvFormat = csvFormat.Replace("L", "{L}");
csvFormat = csvFormat.Replace("C", "{C}");
csvFormat = csvFormat.Replace("V", "{V}");
csvFormat = csvFormat.Replace("F", "{F}");
}
else
{
csvFormat = "{S},{D},{O},{H},{L},{C},{V},{F}";
}
var csvOutputSettings = new CSVOutputSettings();
csvOutputSettings.CSVFormat = csvFormat;
csvOutputSettings.DateFormat = _dateFormat;
csvOutputSettings.Delimiter = ",";
csvOutputSettings.Filename = Path.GetFileName(fileToConvert).Replace("pdf", "csv");
csvOutputSettings.OutputDirectory = _outputPath;
csvOutputSettings.UseSectorValueAsVolume = true;
csvOutputSettings.SectorVolumeDivider = 1000;
pseDocument.ToCSV(csvOutputSettings);
}
}
public static void ConvertFromFiles(object convertFromFilesParamObj)
{
ConvertFromFilesParam convertFromFilesParams = convertFromFilesParamObj as ConvertFromFilesParam;
try
{
if (convertFromFilesParams.OnStartProcess != null)
{
convertFromFilesParams.OnStartProcess();
}
PSEDocument pseDocument = null;
foreach (string reportFile in convertFromFilesParams.FileList)
{
if (convertFromFilesParams.BeforeConvertCallback != null)
{
convertFromFilesParams.BeforeConvertCallback(reportFile);
}
pseDocument = Helpers.LoadFromReportFile(reportFile, convertFromFilesParams.OutputSettings);
if (convertFromFilesParams.ProgressCallback != null)
{
convertFromFilesParams.ProgressCallback(reportFile, pseDocument);
}
}
if (convertFromFilesParams.CompletedCallback != null)
{
convertFromFilesParams.CompletedCallback(pseDocument);
}
}
catch (Exception e)
{
if (convertFromFilesParams.ExceptionCallback != null)
{
convertFromFilesParams.ExceptionCallback(e);
}
}
}
public void Fill(PSEDocument pseDocument, string pseReportFile)
{
_reportString = pseReportFile;
_pseDocument = pseDocument;
InitSectors();
pseDocument.TradeDate = GetTradeDate();
//if (pseDocument.TradeDate.CompareTo(new DateTime(2017, 4, 4)) < 0)
// throw new EUnsupportedReportFormat("Unsupported report format. Quotation reports prior to April 6, 2017 are not supported.");
// PixelSquare: Moved the datel imit to 12-01-2016
if (pseDocument.TradeDate.CompareTo(new DateTime(2016, 12, 1)) < 0)
{
throw new EUnsupportedReportFormat("Unsupported report format. Quotation reports prior to December 1, 2016 are not supported.");
}
CleanupReportString();
ParseReportBody();
ParseSectorSummary();
ParseForeignTransaction();
ParseReportMisc();
}
public void ConvertToAmibroker(PSEDocument pseDocument, AmiOutputSettings amiOutputSettings)
{
if (!System.IO.Directory.Exists(amiOutputSettings.DatabaseDirectory))
{
throw new Exception(amiOutputSettings.DatabaseDirectory + " does not exist");
}
IOperationInvoker amiInvoker = BindingFactory.CreateAutomationBinding("Broker.Application");
amiInvoker.Method("LoadDatabase").AddParameter(amiOutputSettings.DatabaseDirectory).Invoke();
foreach (SectorItem sector in pseDocument.Sectors)
{
SetAmibrokerData(amiInvoker, pseDocument, sector, amiOutputSettings);
foreach (SubSectorItem subSector in sector.SubSectors)
{
foreach (StockItem stockItem in subSector.Stocks)
{
SetAmibrokerData(amiInvoker, pseDocument, stockItem, amiOutputSettings);
}
}
}
amiInvoker.Method("SaveDatabase").Invoke();
amiInvoker.Method("RefreshAll").Invoke();
object x = amiInvoker.Property("Visible").Get <object>();
if (x.ToString() == "0")
{
x = 1;
amiInvoker.Property("Visible").Set(x);
}
if (OnConvertComplete != null)
{
OnConvertComplete(pseDocument, new ConvertEventArgs(amiOutputSettings));
}
}
public static void Convert <T>(PSEDocument pseDocument, T outputSettings)
{
if (outputSettings is CSVOutputSettings)
{
var converter = new CSVConverter();
converter.Execute(pseDocument, outputSettings as CSVOutputSettings);
}
else if (outputSettings is AmiOutputSettings)
{
var converter = new AmibrokerConverter();
converter.Execute(pseDocument, outputSettings as AmiOutputSettings);
}
else if (outputSettings is MetaOutputSettings)
{
var metaOutputSettings = outputSettings as MetaOutputSettings;
CSVOutputSettings csvOutputSettings = new CSVOutputSettings();
csvOutputSettings.DateFormat = "yyyymmdd";
csvOutputSettings.CSVFormat = "{S},M,{D},{O},{H},{L},{C},{V},{F}";
csvOutputSettings.Delimiter = ",";
csvOutputSettings.Filename = "tmp.csv";
csvOutputSettings.SectorVolumeDivider = metaOutputSettings.SectorVolumeDivider;
csvOutputSettings.OutputDirectory = System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
csvOutputSettings.UseSectorValueAsVolume = metaOutputSettings.UseSectorValueAsVolume;
CSVConverter csvConverter = new CSVConverter();
csvConverter.Execute(pseDocument, csvOutputSettings);
string csvFile = csvOutputSettings.OutputDirectory + "\\" + csvOutputSettings.Filename;
MetastockConverter converter = new MetastockConverter(pseDocument, csvFile, metaOutputSettings);
converter.Execute(pseDocument, metaOutputSettings);
}
else
{
throw new Exception("Unsupported setting type.");
}
}
public void Execute(PSEDocument pseDocument, AmiOutputSettings outputSettings)
{
this.PSEDocument = pseDocument;
this.OutputSettings = outputSettings;
this.DoExecute();
}
public void SaveTradeData(PSEDocument pseDocument)
{
}
public void SaveTradeData(PSEDocument pseDocument)
{
var worker = new SaveToDbWorker(DbConnection);
worker.Execute(pseDocument);
}
public void TestReader_SectorSummary()
{
var stripper = new PDFTextStripper();
var reader = new PSEReportReader(stripper.getText(doc).TrimEnd());
var pd = new PSEDocument();
reader.Fill(pd);
// psei
SectorItem psei = pd.GetSector(PSEDocument.PSEI);
ulong expected = 7786326861;
ulong actual = psei.Volume;
Assert.AreEqual(expected, actual, "PSEi volume not equal");
double expected_value = 12960265679.1516;
double actual_value = pd.GetSector(PSEDocument.PSEI).Value;
Assert.AreEqual(expected_value, actual_value, "PSEi value not equal");
expected_value = 3979.97;
actual_value = psei.Open;
Assert.AreEqual(expected_value, actual_value, "PSEi open not equal");
expected_value = 4053.32;
actual_value = psei.High;
Assert.AreEqual(expected_value, actual_value, "PSEi high not equal");
expected_value = 3979.97;
actual_value = psei.Low;
Assert.AreEqual(expected_value, actual_value, "PSEi low not equal");
expected_value = 4053.32;
actual_value = psei.Close;
Assert.AreEqual(expected_value, actual_value, "PSEi close not equal");
// financial
SectorItem financial = pd.GetSector(PSEDocument.FINANCIAL);
expected = 24780801;
actual = financial.Volume;
Assert.AreEqual(expected, actual, "Financial volume not equal");
expected_value = 882690827.9;
actual_value = financial.Value;
Assert.AreEqual(expected, actual, "Financial value not equal");
//913.01 935.52 909.34 935.52 2.47 22.51 24,780,801 882,690,827.9
expected_value = 913.01;
actual_value = financial.Open;
Assert.AreEqual(expected_value, actual_value, "Financial open not equal");
expected_value = 935.52;
actual_value = financial.High;
Assert.AreEqual(expected_value, actual_value, "Financial high not equal");
expected_value = 909.34;
actual_value = financial.Low;
Assert.AreEqual(expected_value, actual_value, "Financial low not equal");
expected_value = 935.52;
actual_value = financial.Close;
Assert.AreEqual(expected_value, actual_value);
// mining
SectorItem mining = pd.GetSector(PSEDocument.MINING_OIL);
expected = 3832444034;
actual = mining.Volume;
Assert.AreEqual(expected, actual, "Mining volume not equal");
expected_value = 977394265.25;
actual_value = mining.Value;
Assert.AreEqual(expected, actual, "Mining value not equal");
//11,644.77 12,468.64 11,644.77 12,387.7 7.97 914.68 3,832,444,034 977,394,265.25
expected_value = 11644.77;
actual_value = mining.Open;
Assert.AreEqual(expected_value, actual_value);
expected_value = 12468.64;
actual_value = mining.High;
Assert.AreEqual(expected_value, actual_value);
expected_value = 11644.77;
actual_value = mining.Low;
Assert.AreEqual(expected_value, actual_value);
expected_value = 12387.7;
actual_value = mining.Close;
Assert.AreEqual(expected_value, actual_value);
SectorItem pse = pd.GetSector(PSEDocument.PSEI);
expected_value = 1938423893.11;
actual_value = pse.NetForeignBuy;
Assert.AreEqual(expected_value, actual_value);
}
public void TestReader_ReportBody()
{
var stripper = new PDFTextStripper();
var reader = new PSEReportReader(stripper.getText(doc).TrimEnd());
var pd = new PSEDocument();
reader.Fill(pd);
//Bid Ask Open High Low Close Volume Value NFB/S
//METROBANK MBT 74.2 74.75 71.2 74.75 71.05 74.75 3,098,980 226,992,448.5 4,289,723
StockItem stock = pd.GetStock("MBT");
double expected = 74.2;
double actual = stock.Bid;
Assert.AreEqual(expected, actual);
expected = 71.2;
actual = stock.Open;
Assert.AreEqual(expected, actual);
expected = 3098980;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 226992448.5;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 4289723;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//PSBANK PSB 51.5 - - - - - - - -
stock = pd.GetStock("PSB");
expected = 0;
actual = stock.High;
Assert.AreEqual(expected, actual);
actual = stock.Volume;
Assert.AreEqual(expected, actual);
actual = stock.Value;
Assert.AreEqual(expected, actual);
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//MANULIFE MFC 557 559 556 560 556 559 160 89,380 (16,680)
stock = pd.GetStock("MFC");
expected = 559;
actual = stock.Close;
Assert.AreEqual(expected, actual);
expected = 160;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 89380;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = -16680;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//ENERGY DEVT. EDC 6.04 6.06 5.76 6.06 5.76 6.06 84,308,100 499,835,886 18,306,534
stock = pd.GetStock("EDC");
expected = 6.06;
actual = stock.Ask;
Assert.AreEqual(expected, actual);
expected = 5.76;
actual = stock.Low;
Assert.AreEqual(expected, actual);
expected = 84308100;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 499835886;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 18306534;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//COSMOS CBC - - - - - - - - -
stock = pd.GetStock("CBC");
expected = 0;
actual = stock.High;
Assert.AreEqual(expected, actual);
actual = stock.Volume;
Assert.AreEqual(expected, actual);
actual = stock.Value;
Assert.AreEqual(expected, actual);
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//VULCAN IND`L VUL 0.81 0.86 0.79 0.86 0.79 0.86 140,000 118,170 -
stock = pd.GetStock("VUL");
expected = 0.86;
actual = stock.Close;
Assert.AreEqual(expected, actual);
expected = 140000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 118170;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 0;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//ANSCOR ANS 3.12 3.15 3.12 3.15 3.12 3.15 227,000 710,740 62,400
stock = pd.GetStock("ANS");
expected = 3.12;
actual = stock.Bid;
Assert.AreEqual(expected, actual);
expected = 3.12;
actual = stock.Open;
Assert.AreEqual(expected, actual);
expected = 227000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 710740;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 62400;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//SEAFRONT RES. SPM 0.95 1.2 - - - - - - -
stock = pd.GetStock("SPM");
expected = 1.2;
actual = stock.Ask;
Assert.AreEqual(expected, actual);
expected = 0;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
actual = stock.Value;
Assert.AreEqual(expected, actual);
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//SINOPHIL SINO 0.305 0.31 0.31 0.31 0.305 0.305 1,190,000 366,450 -
stock = pd.GetStock("SINO");
expected = 0.31;
actual = stock.High;
Assert.AreEqual(expected, actual);
expected = 0.305;
actual = stock.Close;
Assert.AreEqual(expected, actual);
expected = 1190000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 366450;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 0;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//AYALA LAND ALI 17.24 17.26 17.3 17.32 17.1 17.24 7,144,400 123,230,996 (79,735,452)
stock = pd.GetStock("ALI");
expected = 17.24;
actual = stock.Close;
Assert.AreEqual(expected, actual);
expected = 7144400;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 123230996;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = -79735452;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//MARSTEEL B MCB - - - - - - - - -
stock = pd.GetStock("MCB");
expected = 0;
actual = stock.Bid;
Assert.AreEqual(expected, actual);
actual = stock.Open;
Assert.AreEqual(expected, actual);
actual = stock.Close;
Assert.AreEqual(expected, actual);
actual = stock.Volume;
Assert.AreEqual(expected, actual);
actual = stock.Value;
Assert.AreEqual(expected, actual);
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//SM DEVT SMDC 9.35 9.4 8.64 9.8 8.64 9.35 3,641,200 33,750,420 633,735
stock = pd.GetStock("SMDC");
expected = 9.35;
actual = stock.Bid;
Assert.AreEqual(expected, actual);
expected = 8.64;
actual = stock.Low;
Assert.AreEqual(expected, actual);
expected = 3641200;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 33750420;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 633735;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//GMA NETWORK GMA7 7.4 7.45 7.4 7.45 7 7.4 408,500 3,010,200 -
stock = pd.GetStock("GMA7");
expected = 7;
actual = stock.Low;
Assert.AreEqual(expected, actual);
expected = 408500;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 3010200;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 0;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//DIGITEL DGTL 1.51 1.52 1.53 1.54 1.51 1.52 36,056,000 54,884,680 (686,960)
stock = pd.GetStock("DGTL");
expected = 1.53;
actual = stock.Open;
Assert.AreEqual(expected, actual);
expected = 36056000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 54884680;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = -686960;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//WATERFRONT WPI 0.25 0.265 0.27 0.27 0.27 0.27 50,000 13,500 -
stock = pd.GetStock("WPI");
expected = 0.27;
actual = stock.Close;
Assert.AreEqual(expected, actual);
expected = 50000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 13500;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 0;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//GEOGRACE GEO 0.72 0.73 0.7 0.8 0.7 0.73 58,761,000 43,384,240 (7,200)
stock = pd.GetStock("GEO");
expected = 0.8;
actual = stock.High;
Assert.AreEqual(expected, actual);
expected = 58761000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 43384240;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = -7200;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//SEMIRARA MINING SCC 142.1 143 139 145 139 143 569,960 80,377,827 (41,123,492)
stock = pd.GetStock("SCC");
expected = 143;
actual = stock.Ask;
Assert.AreEqual(expected, actual);
expected = 569960;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 80377827;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = -41123492;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
//PHILODRILL A OV 0.014 0.015 0.014 0.015 0.014 0.014 173,200,000 2,525,900 -
stock = pd.GetStock("OV");
expected = 0.014;
actual = stock.Close;
Assert.AreEqual(expected, actual);
expected = 173200000;
actual = stock.Volume;
Assert.AreEqual(expected, actual);
expected = 2525900;
actual = stock.Value;
Assert.AreEqual(expected, actual);
expected = 0;
actual = stock.NetForeignBuy;
Assert.AreEqual(expected, actual);
}
