protected override void Awake()
{
base.Awake();
dayField = GetComponentInParent <DayField>();
googleCalendarWriter = WebManager.Instance.Google.Writer;
reactingObject = GetComponent <ContentCreationButton>();
}
private void PlaceDayFields()
{
float x = bounds.size.x;
float y = bounds.size.y;
float divX = ((x - borderLeft * 2) / numberOfRows);
float divY = ((y - borderTop * 2) / numberOfColumns);
float leftAlign = ((x - borderLeft * 2) / 2);
float topAlign = ((y - borderTop * 2) / 2);
int dayIndex = 0;
bool startIndexing = false;
float divCounterY = divY;
for (int n = 0; n < numberOfColumns; n++)
{
float divCounterX = divX;
float fieldY = gameObject.transform.localPosition.y - divCounterY + topAlign - topAlign / numberOfColumns + divY / 2;
divCounterY += divY;
for (int i = 0; i < numberOfRows; i++)
{
GameObject field = (n == 0) ? GetNewWeekDayField(i) : GetNewDayField();
float fieldX = gameObject.transform.localPosition.x + divCounterX - leftAlign - divX / 2;
field.transform.localPosition = new Vector3(fieldX, fieldY, -0.5f);
field.transform.localRotation = Quaternion.identity;
divCounterX += divX;
if (!startIndexing)
{
if (n == 1 && i == indexFirstDayOfWeekOfMonth)
{ //when first week day of current month is drawn, start counting
dayIndex = 1;
startIndexing = true;
}
else if (n != 0)
{ //if dayField is before first week day of current month
field.SetActive(false);
}
}
if (startIndexing)
{
DayField dayField = field.GetComponent <DayField>();
dayField.representedDay = new DateTime(DateTime.Now.Year, DateTime.Now.Month, dayIndex);
dayFields[dayIndex - 1] = dayField;
dayIndex++;
if (dayIndex > daysInMonth)
{
startIndexing = false;
}
}
}
}
}
public IDoubleMonitor GetLiveCumulativeValueOnDayMonitor(DayField field_, bool forceRegneration_ = false)
{
var key = getMonitorKey("CumulativeDay", field_);
return getorCreateMonitor(key, () => new CumulativeOnDay(this, field_), forceRegneration_);
}
public IDoubleMonitor GetLivePointMonitor(DayField field_, bool forceRegeneration_ = false)
{
var key = getMonitorKey("LivePoint", field_);
return getorCreateMonitor(key, () => new LiveDayValueMonitor(this, field_), forceRegeneration_);
}
private static string getMonitorKey(string type_,DayField field_)
{
return string.Format("{0}_{1}", type_, field_);
}
// shoule be called within the write lock
private void setValue(RelativeDate date_, Line line_, ValueUpdatedEventArgs<DateTime, double> val_, DayField valueField_, DayField volumeField_)
{
BarDataField field = (BarDataField)val_.Index;
switch (field)
{
case BarDataField.Volume:
if(volumeField_==DayField.SpreadVolume)
Logger.Debug(string.Format("Setting {2} for {0} for minute to {1} [date={3}]", Set, val_.Value, volumeField_,date_), typeof (Day));
line_.SetValue(volumeField_, val_.Value);
break;
case BarDataField.Close:
{
line_.SetValue(valueField_, val_.Value);
line_.CalcSeriesValue(DefaultTail);
}
break;
}
if (m_lastUpdated == null || !object.ReferenceEquals(m_lastUpdated, line_))
{
m_lastUpdated = line_;
OnNewLineBeingUpdated(new NewLineUpdatedEventArgs( date_, line_));
}
}
private void backFill(ConstructGen<double> data_, DayField valueField_, DayField volumeField_)
{
if (data_ == null || data_.Dates == null || data_.Dates.Count == 0)
{
Logger.Error(
string.Format("Today's backfill data was empty. Unable to set intraday backfill data for {0} or {1}",
valueField_, volumeField_), typeof(Day));
return;
}
foreach (var key in data_.Keys)
{
var relativeKey = new RelativeDate(IndexedDates, key.ToTZfromGMT(DispTimeZone),DispTimeZone);
if (relativeKey.Index == RelativeDate.INVALID_INDEX)
continue;
m_data.EnsureKey(relativeKey);
var line = m_data.GetValue(relativeKey, 0);
if (line == null)
{
line = new Line {GMTDateTime = key.ToString(Line.MongoDateFormat)};
m_data.SetValue(relativeKey, 0, line);
}
line.SetValue(valueField_, data_.GetValue(key, (int)BarDataField.Close));
line.SetValue(volumeField_, data_.GetValue(key, (int)BarDataField.Volume));
line.CalcSeriesValue(DefaultTail);
}
}
// shoule be called within the write lock
private void setValue(RelativeDate date_, Line line_, ValueUpdatedEventArgs<DateTime, double> val_, DayField valueField_, DayField volumeField_)
{
BarDataField field = (BarDataField)val_.Index;
switch (field)
{
case BarDataField.Volume:
line_.SetValue(volumeField_, val_.Value);
break;
case BarDataField.Close:
{
line_.SetValue(valueField_, val_.Value);
line_.CalcSeriesValue(m_currentRoll.DefaultTail);
}
break;
}
if (m_lastUpdated == null || !object.ReferenceEquals(m_lastUpdated, line_))
{
m_lastUpdated = line_;
OnNewLineBeingUpdated(new NewLineUpdatedEventArgs(RollGeneration.Current, date_, line_));
// keep the previous in sync...
var priorEntry = m_data.GetValue(date_, priorIndex);
OnNewLineBeingUpdated(new NewLineUpdatedEventArgs(RollGeneration.Prior, date_, priorEntry));
}
}
public TotalInDay(Day source_, DayField field_)
:base(source_,field_)
{
}
public double GetValue(DayField field_)
{
switch (field_)
{
case DayField.FrontValue:
return FrontContractValue;
case DayField.FrontVolume:
return FrontContractVolume;
case DayField.BackValue:
return BackContractValue;
case DayField.BackVolume:
return BackContractVolume;
case DayField.SpreadValue:
return SpreadValue;
case DayField.SpreadVolume:
return SpreadVolume;
case DayField.SeriesValue:
return SeriesValue;
default:
return double.NaN;
}
}
internal void SetValue(DayField field_, double value_)
{
switch (field_)
{
case DayField.FrontVolume:
FrontContractVolume = value_;
break;
case DayField.FrontValue:
FrontContractValue = value_;
break;
case DayField.BackVolume:
BackContractVolume = value_;
break;
case DayField.BackValue:
BackContractValue = value_;
break;
case DayField.SpreadVolume:
SpreadVolume = value_;
break;
case DayField.SpreadValue:
SpreadValue = value_;
break;
}
}
public CumulativeOnDay(Day day_, DayField field_)
: base(day_,field_)
{
}
private void backFill(ConstructGen<double> data_, DayField valueField_, DayField volumeField_)
{
if (data_ == null || data_.Dates==null || data_.Dates.Count==0)
{
Logger.Error(
string.Format("Today's backfill data was empty. Unable to set intraday backfil data for {0} or {1}",
valueField_, volumeField_), typeof (LiveDayComparison));
return;
}
foreach (var key in data_.Keys)
{
var relativeKey = new RelativeDate(m_currentRoll.Dates, key);
m_data.EnsureKey(relativeKey);
var line = m_data.GetValue(relativeKey, currentIndex);
if(line==null)
{
line = new Line();
m_data.SetValue(relativeKey, (int)RollGeneration.Current, line);
}
line.SetValue(valueField_, data_.GetValue(key, (int)BarDataField.Close));
line.SetValue(volumeField_, data_.GetValue(key, (int) BarDataField.Volume));
line.CalcSeriesValue(m_currentRoll.DefaultTail);
}
}
public IDoubleMonitor GetTotalInDayMonitor(DayField field_, bool forceRegeneration_ = false)
{
var key = getMonitorKey("totalInDay", field_);
return getorCreateMonitor(key, () => new TotalInDay(this, field_), forceRegeneration_);
}
private static bool LoadFromFile(IEnumerable<string> dirs_, IEnumerable<string> filenames_, DayField valueField_, DayField volumeField_, IDictionary<RelativeDate, Line> values_, Day day_)
{
bool foundAFile = false;
foreach (var dir in dirs_)
{
foreach (var path in filenames_)
{
var files = Directory.GetFiles(dir, path);
if (files.Length == 0)
{
continue;
}
string file = files[0];
Logger.Info(string.Format("Processing file [{0}]", file), typeof(FileHelper));
if (file.EndsWith(".gz"))
file = getUnzippedPath(file);
try
{
foundAFile = true;
foreach (var p in CsvFile.Read<IntradayFileLineItem>(file))
{
if (!p.GmtDate.HasValue)
continue;
var rd = new RelativeDate(day_.IndexedDates, p.GmtDate.Value.ToTZfromGMT(day_.DispTimeZone), day_.DispTimeZone);
if (rd.Index == RelativeDate.INVALID_INDEX) continue;
if (!values_.ContainsKey(rd))
values_[rd] = new Line { GMTDateTime = p.GmtDate.Value.ToString(Line.MongoDateFormat) };
values_[rd].SetValue(valueField_, p.CloseMid);
values_[rd].SetValue(volumeField_, p.Volume);
}
}
catch (Exception ex_)
{
Logger.Error("Error", typeof (FileHelper), ex_);
}
}
}
return foundAFile;
}
public ConstructGenGen<RelativeDate, double> GenerateHourlySums(DayField field_)
{
Func<RelativeDate, RelativeDate, bool> areSameHour = (a, b) => a.UnderlyingDate.IsSameHourAs(b.UnderlyingDate);
try
{
var data = LinesAsRelativeDates();
m_lock.EnterReadLock();
var con = new ConstructGenGen<RelativeDate, double>(1);
if (data == null) return null;
var hour = data.Keys[0];
var sum = 0d;
foreach (var rd in data.Keys)
{
if (areSameHour(hour, rd))
sum += data.GetValue(rd, 0).GetValue(field_);
else
{
con.SetValue(new RelativeDate(hour.IndexDates, hour.UnderlyingDate.StartOfHour(),DispTimeZone), 0, sum);
sum = 0;
hour = rd;
}
}
// do we need to commit last value
var lastHour = new RelativeDate(hour.IndexDates, hour.UnderlyingDate.StartOfHour(),DispTimeZone);
if (con.LastKey() != lastHour)
con.SetValue(lastHour, 0, sum);
return con;
}
finally
{
m_lock.ExitReadLock();
}
}
public ConstructGenGen<RelativeDate, double> GenerateHourlyPoints(DayField field_)
{
Func<RelativeDate, RelativeDate, bool> areSameHour = (a, b) => a.UnderlyingDate.IsSameHourAs(b.UnderlyingDate);
try
{
var data = LinesAsRelativeDates();
m_lock.EnterReadLock();
var con = new ConstructGenGen<RelativeDate, double>(1);
if (data == null) return null;
var hour = data.Keys[0];
con.SetValue(new RelativeDate(hour.IndexDates, hour.UnderlyingDate.StartOfHour(),DispTimeZone), 0, data.GetValue(hour, 0).GetValue(field_));
foreach (var rd in data.Keys)
{
if (areSameHour(hour, rd))
continue;
hour = rd;
con.SetValue(new RelativeDate(hour.IndexDates, hour.UnderlyingDate.StartOfHour(),DispTimeZone), 0, data.GetValue(rd, 0).GetValue(field_));
}
return con;
}
finally
{
m_lock.ExitReadLock();
}
}
public LineValueUpdatedEventArgs(DayField field_, double value_)
{
Field = field_;
Value = value_;
}
private static async Task getFromCarbon(IEnumerable<string> possibleIdentifiers_, IDictionary<RelativeDate, Line> values_, RDDateIndex[] dateIndexes_, DisplayTimeZone zone_, DayField valueField_, DayField volumeField_, CarbonClient cc_)
{
var startDate = dateIndexes_.Select(x => x.Date).Min().AddDays(-3d);
var endDate = dateIndexes_.Select(x => x.Date).Max().AddDays(1d);
var result = await cc_.GetTimeSeriesAsync(possibleIdentifiers_, "intra", startDate, endDate);
if (result == null)
{
Logger.Info(
string.Format("Could not get results back from carbon for tickers=[{0}], with startdate={1} and enddate={2}",
string.Join(",", possibleIdentifiers_),
startDate.ToString("dd-MMM-yyyy"),
endDate.ToString("dd-MMM-yyyy")), typeof (CarbonHelper));
return;
}
foreach (var id in possibleIdentifiers_)
{
var set = result.FirstOrDefault(x => x.Identifier.Equals(id));
if (set == null) continue;
foreach (var row in set.Series)
{
// need to have timestamp and price in order to be a value row...
if (
!row.ContainsKey(CarbonFields.TimeStamp)
|| !row.ContainsKey(CarbonFields.CloseAsk)
|| !row.ContainsKey(CarbonFields.CloseBid))
continue;
var tsGMTstr = row.GetString(CarbonFields.TimeStamp);
DateTime tsGMT;
if (!DateTime.TryParseExact(tsGMTstr, "yyyyMMdd HHmmss.fff", CultureInfo.InvariantCulture,DateTimeStyles.None, out tsGMT))
continue;
// convert gmt to the timezone that we're interested in
var tsTZ = tsGMT.ToTZfromGMT(zone_);
// create a relative date object so we can check if we need this line
var rd = new RelativeDate(dateIndexes_, tsTZ, zone_);
if (rd.Index == RelativeDate.INVALID_INDEX)
continue;
var closeBid = row.GetDouble(CarbonFields.CloseBid);
var closeAsk = row.GetDouble(CarbonFields.CloseAsk);
if (!closeBid.HasValue || !closeAsk.HasValue || closeBid.Value.IsZero() || closeAsk.Value.IsZero())
continue;
var closeMid = (closeBid.Value + closeAsk.Value)/2d;
if (!values_.ContainsKey(rd))
values_[rd] = new Line { GMTDateTime = tsGMT.ToString(Line.MongoDateFormat) };
double volume = 0d;
if (row.ContainsKey(CarbonFields.Volume))
{
var vol = row.GetDouble(CarbonFields.Volume);
volume = vol ?? 0d;
}
values_[rd].SetValue(valueField_, closeMid);
values_[rd].SetValue(volumeField_, volume);
}
// if one of the tickers returned values for the given start/end date, then we don't need to consider the next one
break;
}
}
