public async Task <ActionResult <IReadOnlyList <OrderDto> > > GetOrdersForUser()
{
var email = User.RetrieveEmailFromPrincipal();
var orders = await _orderService.GetOrdersForUserAsync(email);
return(Ok(_mapper.Map <IReadOnlyList <Order>, IReadOnlyList <OrderToReturnDto> >(orders)));
}
public async Task <ActionResult> CreateTransactionist2(int id,
TransactionToCreateVM transactionVM)
{
transactionVM.Email = User.RetrieveEmailFromPrincipal();
// var userId = await _transactionService.GetUserId();
if (await _transactionService.TotalQuantity(transactionVM.Email, id) < transactionVM.Quantity)
{
// stavio si badrequest kako bi ti prošla ona fora od Felipea
// return new BadRequestObjectResult
// (new ApiValidationErrorResponse{Errors = new []{"You are selling more than you have!"}});
return(BadRequest("You are selling more than you have!"));
}
var transaction = new StockTransaction
{
Id = transactionVM.Id,
Date = DateTime.Now,
StockId = id,
Purchase = false,
Quantity = transactionVM.Quantity,
Price = transactionVM.Price,
Resolved = transactionVM.Resolved,
Email = transactionVM.Email
};
var transaction1 = await _transactionService
.CreateTransaction1(transaction, id, User.RetrieveEmailFromPrincipal());
await _transactionService.UpdateTaxLiability(transactionVM.Email);
return(Ok(transaction1));
}
public async Task <ActionResult> CreateTransactionist11(int id, TransactionToCreateVM transactionVM)
{
transactionVM.Email = User.RetrieveEmailFromPrincipal();
await _transactionService.InitialisingTaxLiability(transactionVM.Email);
// ovo stavljaš anual
// await _transactionService.CreatingPurchaseNewAnnualProfitOrLoss(transactionVM.Email);
var transaction = new StockTransaction
{
Id = transactionVM.Id,
Date = DateTime.Now,
StockId = id,
Purchase = true,
Quantity = transactionVM.Quantity,
Price = transactionVM.Price,
Resolved = transactionVM.Resolved,
Email = transactionVM.Email
};
var transaction1 = await _transactionService.CreateTransaction(transaction);
return(Ok(transaction1));
}
public async Task <ActionResult> ReturnLastTransaction()
{
var email = User.RetrieveEmailFromPrincipal();
var lastTransaction = await _transactionService.ReturnLastTranscation(email);
return(Ok(lastTransaction));
}
public async Task <ActionResult> TotalNetProfitForCurrentYear()
{
var email = User.RetrieveEmailFromPrincipal();
decimal?profit = await _transactionService.TotalNetProfitForCurrentYear2(email);
return(Ok(profit));
}
public async Task <ActionResult <FinalTaxLiabilityVM> > GetAnnualByEmail(int id)
{
var email = User.RetrieveEmailFromPrincipal();
var annual = await _taxLiabilitiesService.FindAnnualByEmail(email, id);
return(Ok(annual));
}
public async Task <ActionResult <TaxLiabilityVM> > CheckTotalProfit3(Surtax surtax)
{
var email = User.RetrieveEmailFromPrincipal();
var taxLiability = await _transactionService.ReturnTaxLiability1(email, surtax.Id);
return(Ok(taxLiability));
}
public async Task <ActionResult <decimal> > CheckTotalProfit()
{
var email = User.RetrieveEmailFromPrincipal();
var totalProfit = await _transactionService.TotalNetProfit(email);
return(totalProfit);
}
public async Task <ActionResult <decimal> > ReturnQuantity()
{
var email = User.RetrieveEmailFromPrincipal();
decimal quantity = await __repo.SumQuantityAndAveregePriceForAll(email);
return(Ok(quantity));
}
public async Task <ActionResult> ReturnTotalProfit()
{
var email = User.RetrieveEmailFromPrincipal();
var profit = await _transactionService.ReturnTotalNetProfitOrLoss(email);
return(Ok(profit));
}
// [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
public async Task <ActionResult> GetUserId()
{
// var email = HttpContext.User.Claims.FirstOrDefault(x => x.Type == "email").Value;
var email = User.RetrieveEmailFromPrincipal();
var user = await _userManager.FindByEmailAsync(email);
var userId = user.Id;
return(Ok(userId));
}
public async Task <ActionResult <Order> > ConfirmOrderById(int id, int status)
{
var email = User.RetrieveEmailFromPrincipal();
OrderStatus orderStatus = (OrderStatus)status;
_messagingService.SendMessage($"The status for your order #{id} is now {orderStatus}.");
await _mailService.SendEmailAsync(email, $"Order {orderStatus}", $"<h1>Thank you for your order!</h1><p>Your order #{id} now has the status ${orderStatus}" + DateTime.Now + "</p>");
return(await _rep.ChangeOrderStatus(id, orderStatus));
}
public async Task <ActionResult <int> > GetTotalQuantity(int stockId)
{
var email = User.RetrieveEmailFromPrincipal();
var stock = _stockService.FindStockById(stockId);
var quantity = await _stockService.TotalQuantity(email, stock.Id);
return(Ok(quantity));
}
public async Task <ActionResult <IEnumerable <StockTransaction> > > GetMeFifo()
{
var email = User.RetrieveEmailFromPrincipal();
// var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var list = await _transactionService.Fifo5(email);
var data = _mapper.Map <IEnumerable <StockTransaction>, IEnumerable <TransactionToReturnDto> >(list);
return(Ok(data));
}
public async Task <ActionResult> EditTaxLiability1(
int id)
{
var email = User.RetrieveEmailFromPrincipal();
await _taxLiabilitiesService.UpdateUsersSurtaxId(email, id);
await _taxLiabilitiesService.UpdateTaxLiability2(email, id);
return(NoContent());
}
public async Task <ActionResult <OrderToReturnDto> > GetOrderForUser(int id)
{
var email = User.RetrieveEmailFromPrincipal();
var order = await _orderService.GetOrderByIdAsync(id, email);
if (order == null)
{
return(NotFound(new ApiResponse(404)));
}
return(_mapper.Map <Order, OrderToReturnDto>(order));
}
public async Task <ActionResult <Order> > CreateOrder(OrderDto orderDto)
{
var email = User.RetrieveEmailFromPrincipal();
var address = _mapper.Map <AddressDto, Address>(orderDto.ShipToAddress);
var order = await _orderService.CreateOrderAsync(email, orderDto.DeliveryMethodId, orderDto.BasketId, address);
if (order == null)
{
return(BadRequest(new ApiResponse(400, "Problem creating an order")));
}
return(Ok(order));
}
public async Task <ActionResult> ShowListOfProfitsOrLosses1()
{
var email = User.RetrieveEmailFromPrincipal();
var list = await _chartsService.ShowListOfProfitOrLosses(email);
if (list.Count() > 0)
{
return(Ok(new { list }));
}
return(BadRequest());
}
public async Task <ActionResult <TaxLiabilityDTO> > GetTaxLiabilityByEmail()
{
var email = User.RetrieveEmailFromPrincipal();
var taxLiability = await _taxLiabilitiesService.FindTaxLiabilityByEmail(email);
if (taxLiability == null)
{
return(NotFound());
}
return(_mapper.Map <TaxLiability, TaxLiabilityDTO>(taxLiability));
}
public async Task <ActionResult <IReadOnlyList <Order> > > GetOrdersForUser()
{
var email = User.RetrieveEmailFromPrincipal();
var orders = await _orderService.GetOrdersForUserAsync(email);
if (orders == null)
{
return(NotFound(new ApiResponse(404)));
}
return(Ok(_mapper.Map <IReadOnlyList <OrderToReturnDto> >(orders)));
}
public async Task <ActionResult <bool> > CheckTotalQuantity(int transactionId,
int stockId,
[FromQuery] string quantity)
{
var email = User.RetrieveEmailFromPrincipal();
var transaction = await _transactionsRepo.GetByIdAsync(transactionId);
if (await _transactionService.TotalQuantity(email, stockId) < transaction.Quantity)
{
return(true);
}
return(false);
}
public async Task <ActionResult> ShowListOfProfitsOrLosses()
{
var email = User.RetrieveEmailFromPrincipal();
var list = await _chartsService.ShowListOfProfitOrLosses(email);
if (list == null)
{
return(NotFound());
}
var list1 = _mapper.Map <IEnumerable <AnnualProfitOrLossDto> >(list);
return(Ok(list));
}
public async Task <ActionResult <int> > GetStock1(int id)
{
var email = User.RetrieveEmailFromPrincipal();
var stock = await _stocksRepo.GetByIdAsync(id);
if (stock == null)
{
return(NotFound(new ApiResponse(404)));
}
var stocky = _mapper.Map <Stock, StockToReturnDto1>(stock);
stocky.TotalQuantity = await _stockService.TotalQuantity(email, id);
return(stocky.TotalQuantity);
}
public async Task <ActionResult <TaxLiabilityToEditDTO> > EditTaxLiability(int id,
[FromBody] TaxLiabilityToEditDTO taxLiabilityToEditDto)
{
if (id != taxLiabilityToEditDto.Id)
{
return(BadRequest(new ApiResponse(400, "You lose:)")));
}
var email = User.RetrieveEmailFromPrincipal();
await _taxLiabilitiesService.UpdateUsersSurtaxId(email, taxLiabilityToEditDto.SurtaxId);
await _taxLiabilitiesService.UpdateTaxLiability1(email, taxLiabilityToEditDto);
return(NoContent());
}
public async Task <ActionResult <bool> > CheckTotalQuantity1(
int stockId, int quantity, [FromQuery] string email)
{
email = User.RetrieveEmailFromPrincipal();
var stock = _transactionService.FindStockById(stockId);
var transaction = await _transactionService.GetTransactionByEmailAndId(email, stockId, quantity);
/* transaction.Quantity = quantity;
* transaction.Email = email;
* transaction.StockId = stockId; */
if (await _transactionService
.TotalQuantity(email, stock.Id) < quantity)
{
return(true);
}
return(false);
}
public async Task <ActionResult <StockToReturnDto1> > GetStock(int id)
{
var email = User.RetrieveEmailFromPrincipal();
var spec = new StocksWithCategoriesAndCountriesSpecification(id);
var stock = await _stocksRepo.GetEntityWithSpec(spec);
if (stock == null)
{
return(NotFound(new ApiResponse(404)));
}
var stocky = _mapper.Map <Stock, StockToReturnDto1>(stock);
stocky.TotalQuantity = await _stockService.TotalQuantity(email, id);
return(stocky);
}
public async Task <ActionResult> CreateTransactionist1(int id, TransactionToCreateVM transactionVM)
{
transactionVM.Email = User.RetrieveEmailFromPrincipal();
await _transactionService.InitialisingTaxLiability(transactionVM.Email);
var transaction = new StockTransaction
{
Id = transactionVM.Id,
Date = transactionVM.BuyingDate,
StockId = id,
Purchase = true,
Quantity = transactionVM.Quantity,
Price = transactionVM.Price,
Resolved = transactionVM.Resolved,
Email = transactionVM.Email
};
var transaction1 = await _transactionService.CreateTransaction(transaction);
return(Ok(transaction1));
}
public async Task <ActionResult <TaxLiabilityVM> > CheckTotalProfit11()
{
// var userId = User.FindFirstValue(ClaimTypes.NameIdentifier); // will give the user's userId
// string userId1 = _userManager.GetUserId(HttpContext.User);
//var user = new AppUser();
var id = _userManager.GetUserId(User);
var email = User.RetrieveEmailFromPrincipal();
var user = await _userManager.FindByEmailAsync(email);
string userid7 = await _transactionService.GetUserId7(email);
// var usery = _userManager.FindByIdAsync(user.Id);
//var userId = user.Id;
var taxLiability = await _transactionService.ReturnTaxLiability7(userid7);
return(Ok(taxLiability));
}
public async Task <ActionResult> CreateTransactionist22(int id, TransactionToCreateVM transactionVM)
{
transactionVM.Email = User.RetrieveEmailFromPrincipal();
if (await _transactionService.TotalQuantity(transactionVM.Email, id) < transactionVM.Quantity)
{
return(BadRequest("You are selling more than you have!"));
}
var transaction = await _transactionService.LetsSellStock(transactionVM, id);
await _transactionService.UpdateResolvedAndLocked(transaction, id, User.RetrieveEmailFromPrincipal());
await _transactionService.TwoYearException(transactionVM.Email, transaction);
await _transactionService.UpdateTaxLiabilityIncludingLocked(transactionVM.Email);
// await _transactionService.CreatingLoginNewAnnualProfitOrLoss(transactionVM.Email);
return(NoContent());
}
public async Task <ActionResult <Pagination1 <UserToReturnDto> > > GetUsers(
[FromQuery] QueryParameters queryParameters
)
{
var email = User.RetrieveEmailFromPrincipal();
var list = await _userService.ListAllUsersAsync(email);
if (queryParameters.HasQuery())
{
list = list
.Where(t => t.Email.
ToLowerInvariant().Contains(queryParameters.Query.ToLowerInvariant()));
}
var listy = list.OrderBy(t => t.DisplayName)
.Skip(queryParameters.PageCount * (queryParameters.Page - 1))
.Take(queryParameters.PageCount);
return(Ok(new Pagination1 <UserToReturnDto>
(queryParameters.Page, queryParameters.PageCount, list.Count(), listy)));
}
