Beispiel #1
0
        public async Task <ActionResult> Put(string id, [FromBody] Trade tradeIn)
        {
            try
            {
                Trade registeredTrade = await _tradeRiskService.Get(id);

                if (registeredTrade == null)
                {
                    _responseContext.SetResponseContext(new StatusResponse("Not Found", "Trade not found"));
                    return(_responseContext.GetResponse());
                }

                List <RiskEvaluator> categories = await _tradeCategoriesService.GetRiskCategories();

                RiskEvaluator selectedTradeRisk = categories.Find(rules => rules.VerifyRules(tradeIn));

                if (selectedTradeRisk == null)
                {
                    _responseContext.SetResponseContext(new StatusResponse("Not Found", "The category compatible with these parameters was not found."));
                    return(_responseContext.GetResponse());
                }

                tradeIn.Category = selectedTradeRisk.Category;
                await _tradeRiskService.Update(id, tradeIn);

                _responseContext.SetResponseContext(new TradeResponse(tradeIn));
                return(_responseContext.GetResponse());
            }
            catch (Exception ex)
            {
                _responseContext.SetResponseContext(new ErrorResponse <TradesController>(_logger, ex));
                return(_responseContext.GetResponse());
            }
        }
Beispiel #2
0
        public async Task <ActionResult> Post(List <Trade> portfolio)
        {
            try
            {
                List <RiskEvaluator> categories = await _tradeCategoriesService.GetRiskCategories();

                TradeFactory factory = new TradeRiskFactory();

                List <TradeRisk> tradeRisks    = new List <TradeRisk>();
                List <Object>    invalidTrades = new List <Object>();

                foreach (Trade trade in portfolio)
                {
                    RiskEvaluator selectedTradeRisk = categories.Find(rules => rules.VerifyRules(trade));

                    if (selectedTradeRisk == null)
                    {
                        invalidTrades.Add(new
                        {
                            Value        = trade.Value,
                            ClientSector = trade.ClientSector,
                            Message      = "The category compatible with these parameters was not found."
                        });

                        continue;
                    }

                    TradeRisk tradeRisk = factory.CreateTrade(selectedTradeRisk.Category, trade.Value, trade.ClientSector);

                    await _tradeRiskService.Store(tradeRisk);

                    tradeRisks.Add(tradeRisk);
                }

                _responseContext.SetResponseContext(new StoreTradesResponse(portfolio, tradeRisks, invalidTrades));
                return(_responseContext.GetResponse());
            }
            catch (Exception ex)
            {
                _responseContext.SetResponseContext(new ErrorResponse <TradesController>(_logger, ex));
                return(_responseContext.GetResponse());
            }
        }