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> 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> CreateTransactionist(TransactionToCreateVM transactionVM)
        {
            var transaction = new StockTransaction
            {
                Date     = DateTime.Now,
                UserId   = await _transactionService.GetUserId(),
                StockId  = transactionVM.StockId,
                Purchase = transactionVM.Purchase,
                Quantity = transactionVM.Quantity,
                Price    = transactionVM.Price,
                Resolved = transactionVM.Resolved
            };

            var transaction1 = await _transactionService.CreateTransaction(transaction);

            return(Ok(transaction1));
        }
        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> 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> CreateTransaction(int id, TransactionToCreateVM transactionVM)
        {
            var stock = await _stockService.FindStockById(id);

            if (stock == null)
            {
                return(BadRequest());
            }

            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.CreatingSellingNewAnnualProfitOrLoss1(transactionVM.Email, transaction);

            return(NoContent());
        }