/// <summary>
/// Update collection with points
/// </summary>
/// <param name="point"></param>
protected virtual IPointModel UpdatePoints(IPointModel point)
{
point.Instrument.Points.Add(point);
point.Instrument.PointGroups.Add(point);
return(point);
}
protected override IPointModel UpdatePoints(IPointModel point)
{
point.Instrument.Points.Add(point);
_collection.Add(point, point.Instrument.TimeFrame);
return(point);
}
/// <summary>
/// Next bar event
/// </summary>
/// <param name="pointModel"></param>
/// <returns></returns>
protected bool IsNextPoint(IPointModel pointModel)
{
_date ??= DateTime.MinValue;
if (Equals(pointModel.Time, _date) == false)
{
_date = pointModel.Time;
return(true);
}
return(false);
}
private static List <IRoverCommandItemModel> GetRoverCommandInput(IPointModel upperRight)
{
List <IRoverCommandItemModel> roverCommandList = new List <IRoverCommandItemModel>();
do
{
var rover = GetRoverInput(upperRight);
var moveList = GetMoveListInput();
roverCommandList.Add(new RoverCommandItemModel {
MoveListModel = moveList, RoverModel = rover
});
Consol.WriteColor(ConsoleColor.Yellow, ConsoleColor.Red, ConsoleApp.Properties.Resources.AddNewLabel);
} while ((new List <char> {
'Y', 'y'
}).Contains((char)Console.ReadLine().Trim().First()));
return(roverCommandList);
}
/// <summary>
/// Update missing values of a data point
/// </summary>
/// <param name="point"></param>
protected virtual IPointModel UpdatePointProps(IPointModel point)
{
point.Account = Account;
point.Name = point.Instrument.Name;
point.ChartData = point.Instrument.ChartData;
point.TimeFrame = point.Instrument.TimeFrame;
UpdatePoints(point);
var message = new TransactionMessage <IPointModel>
{
Action = ActionEnum.Create,
Next = point.Instrument.PointGroups.LastOrDefault()
};
DataStream.OnNext(message);
return(point);
}
/// <summary>
/// Helper method to send orders
/// </summary>
/// <param name="point"></param>
/// <param name="side"></param>
/// <param name="size"></param>
/// <returns></returns>
protected ITransactionOrderModel CreateOrder(IPointModel point, OrderSideEnum side, double size)
{
var gateway = point.Account.Gateway;
var instrument = point.Account.Instruments[_asset];
var order = new TransactionOrderModel
{
Size = size,
Side = side,
Instrument = instrument,
Type = OrderTypeEnum.Market
};
gateway.OrderSenderStream.OnNext(new TransactionMessage <ITransactionOrderModel>
{
Action = ActionEnum.Create,
Next = order
});
return(order);
}
public RoverMapValidator(IPointModel pointModel)
{
this.pointModel = pointModel;
RuleFor(x => x).NotNull().NotEmpty();
RuleFor(x => x.X).GreaterThanOrEqualTo(0)
.WithMessage(Properties.Resources.RoverOutsideMapBorderWest)
.WithErrorCode(Constants.ErrorCodes.RETRY);
RuleFor(x => x.Y).GreaterThanOrEqualTo(0)
.WithMessage(Properties.Resources.RoverOutsideMapBorderSouth)
.WithErrorCode(Constants.ErrorCodes.RETRY);
RuleFor(x => x.X).LessThanOrEqualTo(pointModel.X)
.WithMessage(Properties.Resources.RoverOutsideMapBorderEast)
.WithErrorCode(Constants.ErrorCodes.RETRY);
RuleFor(x => x.Y).LessThanOrEqualTo(pointModel.Y)
.WithMessage(Properties.Resources.RoverOutsideMapBorderNorth)
.WithErrorCode(Constants.ErrorCodes.RETRY);
}
private static RectangleRoverModel GetRoverInput(IPointModel upperRight)
{
RectangleRoverModel rectangleRoverModel = new RectangleRoverModel();
RectangleRoverInputValidator validator = new RectangleRoverInputValidator();
RoverMapValidator roverMapValidator = new RoverMapValidator(upperRight);
string rectangleRoverInput;
do
{
do
{
Consol.WriteColor(ConsoleColor.Red, ConsoleApp.Properties.Resources.RoverInputLabel);
rectangleRoverInput = Console.ReadLine().Trim();
} while (CommonValidateInfo(validator, rectangleRoverInput));
string[] values = rectangleRoverInput.Trim().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
rectangleRoverModel.X = Convert.ToInt32(values[0]);
rectangleRoverModel.Y = Convert.ToInt32(values[1]);
rectangleRoverModel.Direction = Enum.Parse <DirectionType>(values[2].ToUpperInvariant());
} while (CommonValidateInfo(roverMapValidator, rectangleRoverModel));
return(rectangleRoverModel);
}
public PointController(IPointModel pointModel)
{
_pointModel = pointModel;
}
public void Setup()
{
upperRightPointModel = new UpperRightPointModel();
upperRightPointModel.X = 10;
upperRightPointModel.Y = 10;
}
/// <summary>
/// Get existing or create new point in the chart series
/// </summary>
/// <param name="pointModel"></param>
/// <param name="direction"></param>
private void UpdatePoint(IPointModel pointModel, double direction = 0.0)
{
if (pointModel.ChartData.Area == null || pointModel.ChartData.Name == null)
{
return;
}
dynamic value = new ExpandoObject();
value.Direction = direction;
value.Point = pointModel?.Last;
value.Low = pointModel?.Bar?.Low;
value.High = pointModel?.Bar?.High;
value.Open = pointModel?.Bar?.Open;
value.Close = pointModel?.Bar?.Close;
var color = pointModel.ChartData.Color;
switch (pointModel.ChartData.Shape)
{
case nameof(ShapeEnum.Line): value.Color = Brushes.Black.Color; break;
case nameof(ShapeEnum.Arrow): value.Color = Brushes.Black.Color; break;
case nameof(ShapeEnum.Bar): value.Color = value.Point > 0 ? Brushes.LimeGreen.Color : Brushes.OrangeRed.Color; break;
case nameof(ShapeEnum.Area): value.Color = value.Point > 0 ? Brushes.LimeGreen.Color : Brushes.OrangeRed.Color; break;
case nameof(ShapeEnum.Candle): value.Color = value.Close > value.Open ? Brushes.LimeGreen.Color : Brushes.OrangeRed.Color; break;
}
if (color.HasValue)
{
value.Color = Color.FromArgb(
color.Value.A,
color.Value.R,
color.Value.G,
color.Value.B);
}
// Update
if (_cache.TryGetValue(pointModel.Time.Value.Ticks, out IInputModel updateModel))
{
updateModel
.Areas[pointModel.ChartData.Area]
.Series[pointModel.ChartData.Name]
.Model = value;
return;
}
// Create
var createModel = new InputModel
{
Time = pointModel.Time.Value,
Areas = new Dictionary <string, IInputAreaModel>()
};
foreach (var area in _groups)
{
createModel.Areas[area.Name] =
createModel.Areas.ContainsKey(area.Name) ?
createModel.Areas[area.Name] :
new InputAreaModel
{
Name = area.Name,
Series = new Dictionary <string, IInputSeriesModel>()
};
foreach (var series in area.ChartData)
{
createModel.Areas[area.Name].Series[series.Key] =
createModel.Areas[area.Name].Series.ContainsKey(series.Key) ?
createModel.Areas[area.Name].Series[series.Key] :
new InputSeriesModel
{
Name = series.Key,
Model = null
};
}
}
createModel
.Areas[pointModel.ChartData.Area]
.Series[pointModel.ChartData.Name]
.Model = value;
_cache[pointModel.Time.Value.Ticks] = createModel;
_points.Add(createModel);
}
/// <summary>
/// Helper method to send orders
/// </summary>
/// <param name="point"></param>
/// <param name="side"></param>
/// <param name="size"></param>
/// <returns></returns>
protected ITransactionOrderModel CreateOrder(IPointModel point, OrderSideEnum side, double size)
{
var gateway = point.Account.Gateway;
var instrument = point.Account.Instruments[_asset];
var order = new TransactionOrderModel
{
Size = size,
Side = side,
Instrument = instrument,
Type = OrderTypeEnum.Market
};
switch (side)
{
case OrderSideEnum.Buy:
order.Orders.Add(new TransactionOrderModel
{
Size = size,
Side = OrderSideEnum.Sell,
Type = OrderTypeEnum.Limit,
Price = point.Ask + 2,
Instrument = instrument,
Container = order
});
order.Orders.Add(new TransactionOrderModel
{
Size = size,
Side = OrderSideEnum.Sell,
Type = OrderTypeEnum.Stop,
Price = point.Bid - 2,
Instrument = instrument,
Container = order
});
break;
case OrderSideEnum.Sell:
order.Orders.Add(new TransactionOrderModel
{
Size = size,
Side = OrderSideEnum.Buy,
Type = OrderTypeEnum.Stop,
Price = point.Bid + 2,
Instrument = instrument,
Container = order
});
order.Orders.Add(new TransactionOrderModel
{
Size = size,
Side = OrderSideEnum.Buy,
Type = OrderTypeEnum.Limit,
Price = point.Ask - 2,
Instrument = instrument,
Container = order
});
break;
}
gateway.OrderSenderStream.OnNext(new TransactionMessage <ITransactionOrderModel>
{
Action = ActionEnum.Create,
Next = order
});
_date = point.Time;
return(order);
}
