public async Task <IActionResult> CreatePortfolio(PortfolioForCreationDto portfolioForCreation)
{
var newPortfolio = _mapper.Map <Portfolio>(portfolioForCreation);
_repo.Add <Portfolio>(newPortfolio);
if (await _repo.SaveAll())
{
portfolioIdForUpload = newPortfolio.Id;
}
return(Ok(newPortfolio));
throw new Exception("Portfolio creation failed on save.");
}
public async Task <IHttpActionResult> UpdateAsync(int id, PortfolioDto portfolio)
{
var portfolioInDb = await _repository.GetAsync(id);
if (portfolioInDb == null)
{
return(NotFound());
}
_repository.Add(portfolio.Map <Portfolio>());
await _unitOfWork.CompleteAsync();
return(Ok());
}
public Task <CreatePortfolioCommandResult> Handle(CreatePortfolioCommand command, CancellationToken cancellationToken)
{
var commandResult = command.Result();
if (!command.Validate())
{
commandResult.AddNotifications(command.Notifications);
return(Incomplete(commandResult));
}
if (_portfolioRepository.CheckNameExists(command.Name))
{
commandResult.AddNotification(nameof(Portfolio), $"Já existe Portfolio com esse nome ({command.Name})");
return(Incomplete(commandResult));
}
var portfolio = new Portfolio(command.Name, _tenantProvider.GetTenantId());
commandResult.AddNotifications(portfolio.Notifications);
if (commandResult.Invalid)
{
return(Incomplete(commandResult));
}
_portfolioRepository.Add(portfolio);
commandResult.Id = portfolio.Id;
return(Complete(commandResult, _portfolioRepository.GetPortfolio(portfolio.Id)));
}
public Portfolio CreatePortfolio(string name, string description, Currency currency)
{
// create a new `Portfolio` class instance
var portfolio = new Portfolio(name, description, currency);
return(portfolio with
{
Id = _portfolioRepository.Add(portfolio)
});
}
public async Task <ActionResult> Create(NewPortfolioViewModel portfolioVm)
{
if (!ModelState.IsValid)
{
return(View(portfolioVm));
}
_portfolios.Add(portfolioVm.Map <Portfolio>());
await _unitOfWork.CompleteAsync();
return(View("List"));
}
public ActionResult <PortfolioDTO> PostPortfolio(Portfolio p)
{
string email = Request.HttpContext.User.Identity.Name;
User u = _uRepository.GetBy(email);
// Console.WriteLine(email);
u.Portfolio = p;
_pRepository.Add(p);
_pRepository.SaveChanges();
PortfolioDTO pdto = new PortfolioDTO {
Name = p.Name, Description = p.Description /*PicturePath = p.PicturePath, ResumePath = p.ResumePath*/
};
return(CreatedAtAction(nameof(GetPortfolio), new { id = p.Id }, pdto));
}
public async Task <IActionResult> CreatePorfolio([FromBody] SavePortfolioResource porfolioResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var porfolio = _mapper.Map <SavePortfolioResource, Portfolio>(porfolioResource);
porfolio.LastUpdate = DateTime.Now;
_repository.Add(porfolio);
await _uow.CompleteAsync();
porfolio = await _repository.GetPortfolio(porfolio.Id);
var result = _mapper.Map <Portfolio, PortfolioResource>(porfolio);
return(Ok(result));
}
public async Task <IActionResult> PostPortfolio([FromBody] Portfolio portfolio)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
await _portfolioRepository.Add(portfolio);
}
catch (ChangeConflictException ex)
{
return(StatusCode((int)HttpStatusCode.Conflict, ex.Message));
}
catch (ToleranceOfOutRangeException ex)
{
return(StatusCode((int)HttpStatusCode.UnprocessableEntity, ex.Message));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
return(CreatedAtAction("GetPortfolio", new { isin = portfolio.ISIN, date = portfolio.Date }, portfolio));
}
public Portfolio Add(Portfolio entity)
{
entity = repository.Add(entity);
unitOfWork.Commit();
return(entity);
}
/// <summary>
/// Adds a new Portfolio
/// </summary>
/// <param name="newPortfolio">Portfolio object</param>
/// <returns></returns>
public async Task Add(Portfolio newPortfolio)
{
await _portfolioRepository.Add(newPortfolio);
}