public object createPointData(GraphPeriod period, Graph x, GraphSerialsRel rel)
{
if (period.Range.Count == 1)
{
period.Range.Insert(0, new GraphPeriod(period.Days, period.RangeOrders)
{
MinDate = period.MinDate.Value.Date.AddDays(-2 * period.Days),
MaxDate = period.MinDate.Value.Date.AddDays(-1 * period.Days),
});
period.Range.Add(new GraphPeriod(period.Days, period.RangeOrders)
{
MinDate = period.MaxDate.Value.Date,
MaxDate = period.MaxDate.Value.Date.AddDays(period.Days),
});
}
return(period.Range.Select(
(z, index) =>
new
{
Label = GraphPeriod.CreateLiteralRange(z.MinDate.Value, z.MaxDate.Value),
Value =
period.Calculate(index, rel.SerialID, x.GraphTypeFunc.Func,
x.GraphTypeFunc.TypeID),
}).Where(z => z.Value != null).ToArray());
}
public int iLowest(string symbol, GraphPeriod timeFrame, int type, int count, int start)
{
AsyncCommand aCmd = new AsyncCommand(Commands.ILowest,
new object[] { symbol, (int)timeFrame, type, count, start });
return((int)ExecuteCommand(aCmd));
}
public int iBarShift(string symbol, GraphPeriod timeFrame, DateTime dateTime, bool exact)
{
AsyncCommand aCmd = new AsyncCommand(Commands.IBarShift,
new object[] { symbol, (int)timeFrame, Convertor.DateTimeToSeconds(dateTime), exact ? 1 : 0 });
return((int)ExecuteCommand(aCmd));
}
public int iBars(string symbol, GraphPeriod timeFrame)
{
AsyncCommand aCmd = new AsyncCommand(Commands.IBars,
new object[] { symbol, (int)timeFrame });
return((int)ExecuteCommand(aCmd));
}
public ActionResult GraphFilter(int id)
{
var graph = DB.Graphs.FirstOrDefault(x => x.ID == id);
if (graph != null)
{
var range = new GraphPeriod(graph.Period ?? 1);
var orders =
graph.GraphSerialsRels.SelectMany(x => x.GraphSerial.GraphSerialsOrders)
.Select(x => x.Order)
.ToList();
range.InitRange(
graph.MinDate.HasValue
? graph.MinDate
: (orders.Any() ? orders.Min(x => x.CreateDate) : (DateTime?)null),
graph.MaxDate.HasValue
? graph.MaxDate
: (orders.Any() ? orders.Max(x => x.CreateDate) : (DateTime?)null), orders);
range.Serials = graph.GraphSerialsRels;
range.ID = id;
range.TypeID = graph.GraphTypeFunc.TypeID;
return(PartialView(range));
}
return(PartialView(null));
}
public int iClose(string symbol, GraphPeriod timeFrame, int shift)
{
AsyncCommand aCmd = new AsyncCommand(Commands.IClose,
new object[] { symbol, (int)timeFrame, shift });
int retValue = Convertor.TranslateToPipPrice(symbol, (double)ExecuteCommand(aCmd));
if (retValue == 0)
{
throw new ApplicationException("Local history is empty or meta is stupid f... thing");
}
return(retValue);
}
public double iVolume(string symbol, GraphPeriod timeFrame, int shift)
{
AsyncCommand aCmd = new AsyncCommand(Commands.IVolume,
new object[] { symbol, (int)timeFrame, shift });
double retValue = (double)ExecuteCommand(aCmd);
if (Math.Abs(retValue) <= Double.Epsilon)
{
throw new ApplicationException("Local history is empty or meta is stupid f... thing");
}
return(retValue);
}
public DateTime iTime(string symbol, GraphPeriod timeFrame, int shift)
{
AsyncCommand aCmd = new AsyncCommand(Commands.ITime,
new object[] { symbol, (int)timeFrame, shift });
int retValue = (int)ExecuteCommand(aCmd);
if (retValue == 0)
{
throw new ApplicationException("Local history is empty or meta is stupid f... thing");
}
return(Convertor.SecondsToDateTime(retValue));
}
public ActionResult GraphFilter(GraphPeriod period, FormCollection collection)
{
var graph = DB.Graphs.FirstOrDefault(x => x.ID == period.ID);
if (graph != null)
{
graph.Period = period.Days;
if (period.MinDateThresh.HasValue && period.MinDate.HasValue)
{
if (period.MinDate < period.MinDateThresh)
{
period.MinDate = period.MinDateThresh;
}
}
if (period.MaxDateThresh.HasValue && period.MaxDate.HasValue)
{
if (period.MaxDate > period.MaxDateThresh)
{
period.MaxDate = period.MaxDateThresh;
}
}
if (period.MinDate.HasValue && period.MaxDate.HasValue)
{
if (period.MinDate > period.MaxDate)
{
period.MinDate = period.MaxDate.Value.AddDays(-1);
}
var days = (int)(period.MaxDate.Value.Subtract(period.MinDate.Value).TotalDays / 2);
if (days < 1)
{
days = 1;
}
var allowed = period.AllPeriods.OrderBy(x => x).Last(x => x <= days);
if (allowed < period.Days)
{
graph.Period = allowed;
}
}
graph.MinDate = period.MinDate;
graph.MaxDate = period.MaxDate;
DB.SubmitChanges();
return(GraphFilter(graph.ID));
}
return(PartialView(null));
}
public ActionResult Issue(GraphPeriod gp)
{
GraphData wg = new GraphData(gp);
var Chart1 = new Chart();
Chart1.Width = 500;
Chart1.Height = 350;
Title title = new Title(wg.Title);
title.Font = new Font("Calibri", 12, FontStyle.Underline);
Chart1.Titles.Add(title);
var area = new ChartArea("ChartArea1");
Chart1.ChartAreas.Add(area);
Series series = new Series("Issues", 10);
series.Points.DataBindXY(wg.Keys, wg.Values);
// Populate series data
series.IsValueShownAsLabel = true;
//series.LabelBackColor = Color.White;
//series.LabelBorderColor = Color.Black;
series["LabelStyle"] = "Bottom";
series.Palette = gp == GraphPeriod.week? ChartColorPalette.SeaGreen : ChartColorPalette.EarthTones;
series.EmptyPointStyle.IsValueShownAsLabel = false;
series.EmptyPointStyle["EmptyPointValue"] = "Zero";
// Set Doughnut chart type
series.ChartType = SeriesChartType.Column;
Chart1.Series.Add(series);
// Enable 3D
Chart1.ChartAreas["ChartArea1"].Area3DStyle.Enable3D = false;
// Disable the Legend
Chart1.Legends.Add("Legend1");
// show legend based on check box value
Chart1.Legends["Legend1"].Enabled = false;
var returnStream = new MemoryStream();
Chart1.ImageType = ChartImageType.Png;
Chart1.SaveImage(returnStream);
returnStream.Position = 0;
return(new FileStreamResult(returnStream, "image/png"));
}
public object createSubSeq(Graph x)
{
var period = new GraphPeriod(x.Period ?? 1);
period.InitRange(x.MinDate, x.MaxDate, x.GraphSerialsRels.SelectMany(z => z.GraphSerial.GraphSerialsOrders).Select(z => z.Order).ToList());
var array = new List <object>();
foreach (var rel in x.GraphSerialsRels.Where(c => !c.IsHidden))
{
array.Add(
new
{
Color = rel.Color,
Name = rel.GraphSerial.Name,
PointData = createPointData(period, x, rel)
}
);
}
return(array);
}
private List <string> GetDateList(GraphPeriod period, DateTime startDate, DateTime endDate)
{
List <TransactionItem> items = TransactionItem.GetCollection().Find(t => t.TransDate >= startDate && t.TransDate <= endDate).ToList();
switch (period)
{
case GraphPeriod.Annual:
return(items.Select(i => i.TransDate.ToString("yyyy")).Distinct().ToList());
case GraphPeriod.Monthly:
return(items.Select(i => i.TransDate.ToString(DATEFORMAT)).Distinct().ToList());
case GraphPeriod.Weekly:
DateTimeFormatInfo dfi = DateTimeFormatInfo.CurrentInfo;
Calendar cal = dfi.Calendar;
return(items.Select(i => string.Format("Week {0} {1}", cal.GetWeekOfYear(i.TransDate, dfi.CalendarWeekRule, dfi.FirstDayOfWeek), i.TransDate.ToString("yyyy"))).Distinct().ToList());
default:
return(new List <string>());
}
}
private bool IsDateInPeriod(string periodDate, DateTime dateToCheck, GraphPeriod period)
{
switch (period)
{
case GraphPeriod.Annual:
return(periodDate == dateToCheck.ToString("yyyy"));
case GraphPeriod.Monthly:
return(periodDate == dateToCheck.ToString(DATEFORMAT));
case GraphPeriod.Weekly:
DateTimeFormatInfo dfi = DateTimeFormatInfo.CurrentInfo;
Calendar cal = dfi.Calendar;
return(periodDate == string.Format("Week {0} {1}",
cal.GetWeekOfYear(dateToCheck, dfi.CalendarWeekRule,
dfi.FirstDayOfWeek), dateToCheck.ToString("yyyy")));
default:
return(false);
}
}
public OPTReport(GraphPeriod timeframe, DateTime dateProvided)
{
switch (timeframe)
{
case GraphPeriod.daily:
startDate = dateProvided;
endDate = startDate.AddDays(1).AddSeconds(-1);
title = string.Format("OPT Data for {0} ", startDate.ToShortDateString());
break;
case GraphPeriod.week:
startDate = dateProvided.StartOfWeek(DayOfWeek.Monday);
endDate = startDate.AddDays(7).AddSeconds(-1);
title = string.Format("OPT Data between {0} and {1}", startDate.ToShortDateString(), endDate.ToShortDateString());
break;
case GraphPeriod.month:
startDate = dateProvided.StartOfMonth();
endDate = startDate.AddMonths(1).AddSeconds(-1);
title = string.Format("OPT Data for {0}", startDate.ToString("MMMM yyyy"));
break;
case GraphPeriod.year:
startDate = dateProvided.StartOfYear();
endDate = startDate.AddYears(1).AddSeconds(-1);
title = string.Format("OPT Data for {0}", startDate.ToString("yyyy"));
break;
default:
break;
}
data = new List <OPTRow>();
data.Add(new OPTRow("CA", startDate, endDate));
foreach (var div in myDBContextHelper.CurrentContext.Divisions.Where(d => d.active == true))
{
data.Add(new OPTRow(div.Detail, startDate, endDate));
}
}
public PartialViewResult OPTReport(GraphPeriod period, DateTime chosenDate)
{
OPTReport rpt = new OPTReport(period, chosenDate);
return(PartialView("_OPTReport", rpt));
}
public GraphData(GraphPeriod gp)
{
graphPeriod = gp;
IEnumerable <Warrant> w = db.Warrants.Where(c => c.createdOn >= startDate).OrderBy(c => c.division.Detail);
switch (graphPeriod)
{
case GraphPeriod.week:
prefix = "w/c";
startDate = DateTime.Now.StartOfWeek(DayOfWeek.Monday);
displayDate = startDate.ToString("d MMM yyyy");
break;
case GraphPeriod.month:
prefix = "";
startDate = DateTime.Today.StartOfMonth();
displayDate = startDate.ToString("MMMM yyyy");
break;
case GraphPeriod.year:
prefix = "";
startDate = Convert.ToDateTime(string.Format("1/1/{0}", DateTime.Now.Year.ToString()));
displayDate = startDate.ToString("yyyy");
break;
default:
break;
}
gData.Add("Child Abductions", db.ChildAbductions.Where(c => c.createdOn >= startDate).Count());
gData.Add("Bankruptcy", db.Warrants.Where(c => c.createdOn >= startDate).OrderBy(c => c.division.Detail).Where(d => d.division.Detail == "Bankruptcy").Count());
gData.Add("Chancery", db.Warrants.Where(c => c.createdOn >= startDate).OrderBy(c => c.division.Detail).Where(e => e.division.Detail == "Chancery").Count());
gData.Add("Family", db.Warrants.Where(c => c.createdOn >= startDate).OrderBy(c => c.division.Detail).Where(c => c.division.Detail == "Family").Count());
gData.Add("Insolvency", db.Warrants.Where(c => c.createdOn >= startDate).OrderBy(c => c.division.Detail).Where(c => c.division.Detail == "Insolvency").Count()); // null);//
gData.Add("Queen's Bench", db.Warrants.Where(c => c.createdOn >= startDate).OrderBy(c => c.division.Detail).Where(c => c.division.Detail == "Queen's Bench").Count());
if (gData["Child Abductions"] == 0)
{
gData["Child Abductions"] = null;
}
if (gData["Bankruptcy"] == 0)
{
gData["Bankruptcy"] = null;
}
if (gData["Chancery"] == 0)
{
gData["Chancery"] = null;
}
if (gData["Family"] == 0)
{
gData["Family"] = null;
}
if (gData["Insolvency"] == 0)
{
gData["Insolvency"] = null;
}
if (gData["Queen's Bench"] == 0)
{
gData["Queen's Bench"] = null;
}
}
public double iVolume(string symbol, GraphPeriod timeFrame, int shift)
{
throw new NotImplementedException();
}
public DateTime iTime(string symbol, GraphPeriod timeFrame, int shift)
{
throw new NotImplementedException();
}
public int iOpen(string symbol, GraphPeriod timeFrame, int shift)
{
return(HistoryGroupTick(shift).OpenBid);
}
public int iLowest(string symbol, GraphPeriod timeFrame, int type, int count, int start)
{
throw new NotImplementedException();
}
public int iHigh(string symbol, GraphPeriod timeFrame, int shift)
{
return(HistoryGroupTick(shift).MaxBid);
}
public int iClose(string symbol, GraphPeriod timeFrame, int shift)
{
return(HistoryGroupTick(shift).CloseBid);
}
public int iBarShift(string symbol, GraphPeriod timeFrame, DateTime dateTime, bool exact)
{
throw new NotImplementedException();
}
public int iBars(string symbol, GraphPeriod timeFrame)
{
throw new NotImplementedException();
}
public int iOpen(string symbol, GraphPeriod timeFrame, int shift)
{
throw new NotImplementedException();
}
public void GeneratePointsLists(GraphPeriod period, bool addTotal = true, bool addTrend = false, DateTime?startDate = null, DateTime?endDate = null)
{
if (startDate == null || startDate.Value <= DateTime.MinValue || startDate.Value >= DateTime.MaxValue)
{
startDate = TransactionItem.GetCollection().Find(t => t.TransDate > DateTime.MinValue).Min(t => t.TransDate).AddDays(-1);
}
if (endDate == null || endDate.Value <= DateTime.MinValue || endDate.Value >= DateTime.MaxValue)
{
endDate = DateTime.Today;
}
_period = period;
cmbType.SelectedItem = period;
_startDate = startDate.Value;
_endDate = endDate.Value;
dtpStartDate.Value = startDate.Value;
dtpEndDate.Value = endDate.Value;
Dictionary <string, List <object>[]> data = new Dictionary <string, List <object>[]>();
List <string> dates = GetDateList(_period, _startDate, _endDate);
// Make the intervals match up with the number of entries we have
switch (period)
{
case GraphPeriod.Annual:
break;
case GraphPeriod.Monthly:
chart1.ChartAreas[0].AxisX.Interval = Math.Min(3, Math.Ceiling(((_endDate - _startDate).Days / 30) / 12.0d));
break;
case GraphPeriod.Weekly:
chart1.ChartAreas[0].AxisX.Interval = Math.Min(5, Math.Ceiling(((_endDate - _startDate).Days / 7) / 26.0d));
break;
}
chart1.Titles[0].Text = period.ToString();
// group by account
var items = TransactionItem.GetCollection().FindAll().GroupBy(i => i.Account);
foreach (var group in items)
{
List <object>[] dateAndAmount = new List <object> [2];
dateAndAmount[0] = new List <object>();
dateAndAmount[1] = new List <object>();
// group by date
foreach (string date in dates)
{
string lastDate = string.Empty;
decimal balance = 0.00M;
// search transactions
foreach (TransactionItem item in group)
{
// Janky, but the best way we can do this without having both a date and a time for each transaction
// is to go through the list until you find the first applicable transaction for a given period and
// add it to the list of data points. While this may be inaccurate on an individual by-date level,
// it should show a consistent level over a number of data points
if (IsDateInPeriod(date, item.TransDate, period))
{
lastDate = date;
balance = item.Balance;
}
}
if (!string.IsNullOrEmpty(lastDate))
{
dateAndAmount[0].Add(lastDate);
dateAndAmount[1].Add(balance);
}
else
{
if (dateAndAmount[1].Count > 0)
{
dateAndAmount[0].Add(date);
dateAndAmount[1].Add(dateAndAmount[1].Last());
}
}
}
data.Add(GetFriendlyAccountNames(group.Key), dateAndAmount);
}
// If we want to add a total over all the accounts
if (addTotal)
{
List <object>[] dateAndAmount = new List <object> [2];
dateAndAmount[0] = new List <object>();
dateAndAmount[1] = new List <object>();
// go through each possible date
foreach (string date in dates)
{
decimal total = 0.00M;
// go through each account
foreach (KeyValuePair <string, List <object>[]> kvp in data)
{
// search each row...
for (int i = 0; i < kvp.Value[0].Count; i++)
{
// look for the corresponding date
if (((string)kvp.Value[0][i]) == date)
{
// add to the running total
total += (decimal)kvp.Value[1][i];
break;
}
}
}
dateAndAmount[0].Add(date);
dateAndAmount[1].Add(total);
}
data.Add("Total", dateAndAmount);
}
if (addTrend)
{
List <object>[] dateAndAmount = data["Total"];
if (dateAndAmount != null && dateAndAmount[0].Count > 0)
{
decimal slope = (((decimal)dateAndAmount[1].Last()) - ((decimal)dateAndAmount[1].First())) / (decimal)dateAndAmount[1].Count;
decimal intercept = (decimal)dateAndAmount[1].First();
List <object>[] trendLine = new List <object> [2];
trendLine[0] = new List <object>();
trendLine[1] = new List <object>();
for (int i = 0; i < dateAndAmount[0].Count; i++)
{
trendLine[0].Add(dateAndAmount[0][i]);
trendLine[1].Add(intercept + (slope * i));
}
switch (period)
{
case GraphPeriod.Monthly:
trendLine[0].Add("Next month");
trendLine[1].Add(intercept + (slope * dateAndAmount[0].Count));
break;
case GraphPeriod.Weekly:
for (int i = 0; i < 4; i++)
{
trendLine[0].Add("Next week " + (i + 1).ToString());
trendLine[1].Add(intercept + (slope * (dateAndAmount[0].Count + i)));
}
break;
default:
break;
}
data.Add("Trend", trendLine);
}
}
else
{
List <object>[] dateAndAmount = data["Total"];
if (dateAndAmount != null && dateAndAmount[0].Count > 0)
{
List <object>[] trendLine = new List <object> [2];
trendLine[0] = new List <object>();
trendLine[1] = new List <object>();
trendLine[0].Add(dateAndAmount[0][0]);
trendLine[1].Add(dateAndAmount[1][0]);
data.Add("Trend", trendLine);
}
}
foreach (KeyValuePair <string, List <object>[]> kvp in data)
{
AddPoints(kvp.Value[0], kvp.Value[1], kvp.Key);
}
}
