public SellOrderResponseDto Execute(SellOrdersRequestDto request)
{
var validateRequest = ValidateRequestStructure.Execute(request);
if (validateRequest.Any())
{
return(SellOrderResponseDto.Build(validateRequest, null));
}
var validateBusinessRules = validateSellOrderBusinessRules.Execute(request);
if (validateBusinessRules.ErrorList != null && validateBusinessRules.ErrorList.Any())
{
messageErrorList.AddRange(validateBusinessRules.ErrorList);
}
request.OrderList = validateBusinessRules.Result;
var sellOrderProcess = processSellOrder.Execute(request);
if (sellOrderProcess.ErrorList != null && sellOrderProcess.ErrorList.Any())
{
messageErrorList.AddRange(sellOrderProcess.ErrorList);
}
return(SellOrderResponseDto.Build(messageErrorList, sellOrderProcess.Result));
}
internal OperationResult <CurrentBalanceDto> Execute(SellOrdersRequestDto request)
{
currentBalance = CurrentBalanceDto.ConvertFromInitialBalance(request.InitialBalance);
if (!request.OrderList.Any())
{
return(new OperationResult <CurrentBalanceDto>(currentBalance));
}
messageErrorList = new List <ErrorDto>();
var orderList = request.OrderList.OrderBy(x => x.TimeStamp).ToList();
orderList.ForEach(x =>
{
switch (x.Operation)
{
case "SELL":
SellOperation(x);
break;
case "BUY":
BuyOperation(x);
break;
}
});
return(new OperationResult <CurrentBalanceDto>(currentBalance, messageErrorList, true));
}
private OperationResult <SellOrdersRequestDto> MapAndValidateFileStructure(IEnumerable <string> fileLines)
{
if (fileLines == null || fileLines.Count() < 2)
{
return(new OperationResult <SellOrdersRequestDto>(ErrorDto.BuildUser("Structure file {0}, is incorrect")));
}
var fileProcess = fileLines.ToArray();
var initialBalance = new InitialBalanceDto();
var orderList = new List <OrderDto>();
for (int i = 0; i < fileProcess.Length; i++)
{
if (i == 0)
{
var processInitiBalalance = deserialize.Execute <InitialBalanceJsonDto>(fileProcess[i]);
if (processInitiBalalance.Failure)
{
return(new OperationResult <SellOrdersRequestDto>(processInitiBalalance.ErrorList));
}
initialBalance = processInitiBalalance.Result.InitialBalance;
}
else
{
var processOrder = deserialize.Execute <OrderDto>(fileProcess[i]);
if (processOrder.Failure)
{
return(new OperationResult <SellOrdersRequestDto>(processOrder.ErrorList));
}
if (processOrder.Result != null)
{
orderList.Add(processOrder.Result);
}
}
}
var response = new SellOrdersRequestDto()
{
InitialBalance = initialBalance,
OrderList = orderList
};
return(new OperationResult <SellOrdersRequestDto>(response));
}
internal static IEnumerable <ErrorDto> Execute(SellOrdersRequestDto request)
{
var messageErrorList = new List <ErrorDto>();
if (request == null)
{
messageErrorList.Add(ErrorDto.BuildUser("Request can't be null."));
return(messageErrorList);
}
;
if (request.InitialBalance == null)
{
messageErrorList.Add(ErrorDto.BuildUser("InitialBalance can't be null."));
}
if (request.OrderList == null || !request.OrderList.Any())
{
messageErrorList.Add(ErrorDto.BuildUser("Your need at least one order for the process."));
}
return(messageErrorList);
}
internal OperationResult <IEnumerable <OrderDto> > Execute(SellOrdersRequestDto request)
{
var goodOrder = new List <OrderDto>();
var messageErrorList = new List <ErrorDto>();
goodOrder.AddRange(request.OrderList.Where(
x => {
var correct = true;
if (!validOperation.Any(y => y == x.Operation) || (x.TotalShares <= 0))
{
correct = false;
messageErrorList.Add(ErrorDto.BuildUser(
string.Format("Issuer {0} with operation {1} is invalid.", x.IssuerName, x.Operation),
INVALID_OPERATION_CODE));
return(correct);
}
if (!(x.TimeStamp.TimeOfDay >= InitialHourDay && x.TimeStamp.TimeOfDay <= FinalHourDay))
{
correct = false;
messageErrorList.Add(ErrorDto.BuildUser(
string.Format("Issuer {0} with time {1} is invalid (closed market).", x.IssuerName, x.TimeStamp),
CLOSED_MARKET_CODE));
return(correct);
}
return(correct);
}).Select(x => x).ToList());
var goodOrderGroup = goodOrder.GroupBy(x => x.IssuerName);
goodOrder = new List <OrderDto>();
foreach (var item in goodOrderGroup)
{
if (item.Any(x => x.Operation == SELL_OPERATION) && !request.InitialBalance.IssuerList.Any(x => x.IssuerName == item.Key))
{
messageErrorList.Add(ErrorDto.BuildUser(
string.Format("Issuer {0} can't be operation {1} because doesn't exist in initial balance.", item.Key, SELL_OPERATION),
INSUFFICIENT_STOCKS_CODE));
continue;
}
if (item.Count() == 1)
{
goodOrder.AddRange(item.Select(x => x));
continue;
}
var indexOrder = item.Select((x, y) => new { order = x, indx = y });
goodOrder.AddRange(indexOrder.Where(x =>
{
var correct = true;
if (indexOrder.Any(z => z.indx != x.indx && z.order.Operation == x.order.Operation && z.order.StayFiveMinutes(x.order.TimeStamp)))
{
correct = false;
messageErrorList.Add(ErrorDto.BuildUser(
string.Format("Issuer {0} with timestamp {1} is duplicated with another records.", x.order.IssuerName, x.order.TimeStamp),
DUPLICATED_OPERATION_CODE));
}
return(correct);
}).Select(x => x.order).ToList());
}
return(new OperationResult <IEnumerable <OrderDto> >(goodOrder, messageErrorList, true));
}
