Exemplo n.º 1
0
        public ActionResult DeleteConfirmed(TransactionPostModel model)
        {
            var BLmodel = _mapper.Map <TransactionModel>(model);

            _transactionService.Remove(BLmodel);
            return(RedirectToAction("Index"));
        }
Exemplo n.º 2
0
        public async Task <IActionResult> Post([FromBody] TransactionPostModel postModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(new ErrorResponse {
                    StatusCode = 400, Message = "Uncorrect data"
                }));
            }

            var user = await userService.FindUserByEmailOrNameAsync(postModel.Recipient.Email, postModel.Recipient.Name);

            if (user == null)
            {
                return(BadRequest(new ErrorResponse {
                    StatusCode = 400, Message = "This user is not registered"
                }));
            }

            var transaction = mapper.Map <TransactionPostModel, Transaction>(postModel);

            try
            {
                await transactionService.SendTransactionAsync(User.GetUserId(), transaction, user);
            }
            catch (Exception ex)
            {
                return(BadRequest(new ErrorResponse {
                    StatusCode = 400, Message = ex.Message
                }));
            }

            return(Ok());
        }
Exemplo n.º 3
0
 public ActionResult Edit([Bind(Include = "Id,Value,Description,Title,CreatedDate,UpdatedDate")] TransactionPostModel transactionModel)
 {
     if (ModelState.IsValid)
     {
         _transactionService.Update(_mapper.Map <TransactionModel>(transactionModel));
         return(RedirectToAction("Index"));
     }
     return(View(transactionModel));
 }
Exemplo n.º 4
0
        public ActionResult Delete(TransactionPostModel model)
        {
            if (model.Id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var models = _mapper.Map <IEnumerable <TransactionPostModel> >(_transactionService.GetAll());
            TransactionPostModel transactionModel = models.FirstOrDefault(x => x.Id == model.Id);

            if (transactionModel == null)
            {
                return(HttpNotFound());
            }
            return(View(transactionModel));
        }
        public async Task Send_Transaction_Ok()
        {
            //arrage
            var currentUser = CreateTestUser("test 1", "*****@*****.**");

            controller.ControllerContext = new ControllerContext
            {
                HttpContext = new DefaultHttpContext()
                {
                    User = CreateUserPrincipal(currentUser)
                }
            };

            var testUser = CreateTestUser("test 2", "*****@*****.**");

            var transactionPM = new TransactionPostModel
            {
                Amount    = 100,
                Message   = "test message",
                Recipient = new WebAPI.ViewModels.Account.UserViewModel
                {
                    Name  = testUser.Name,
                    Email = testUser.Email
                }
            };

            var transaction = new Transaction
            {
                Amount  = transactionPM.Amount,
                Message = transactionPM.Message
            };

            userService.Setup(x => x.FindUserByEmailOrNameAsync(It.IsAny <string>(), It.IsAny <string>()))
            .Returns(Task.FromResult(testUser));

            transactionService.Setup(x => x.SendTransactionAsync(currentUser.UserId, transaction, testUser))
            .Returns(Task.CompletedTask)
            .Verifiable();

            //act
            var action = await controller.Post(transactionPM);

            //assert
            var result = Assert.IsType <OkResult>(action);

            Assert.Equal(result.StatusCode, 200);
        }
        public ActionResult AddTransaction([FromBody] TransactionPostModel transactionInput)
        {
            if (transactionInput == null)
            {
                BadRequest();
            }

            var transaction = new Transaction("sender", transactionInput.Receiver, transactionInput.Ammount);

            var block = blockchainService.AddTransaction(new List <Transaction>()
            {
                transaction
            });

            transactionBroadcastManager.BroadcastNewBlock(block);

            return(Ok());
        }