Beispiel #1
0
        public CreateCardResponse AddCard(CreateCard createCard)
        {
            HttpResponseMessage response           = null;
            CreateCardResponse  createCardResponse = null;

            CreateCardHandler createCardHandler = new CreateCardHandler
                                                  (
                createCard.Key,
                createCard.Token,
                createCard.BacklogListId,
                createCard.Topic.Description,
                createCard.Topic
                                                  );

            response = Post(IntegrationTypes.Card, createCardHandler);

            if (!response.IsSuccessStatusCode)
            {
                createCard.AddNotification("CreateCard", $"Ocorreu erro ao criar o cartão {createCard.Topic.Description}. Retorno API: ({response.StatusCode}) {response.Content.ReadAsStringAsync().Result}");
                return(createCardResponse);
            }

            createCardResponse = response.Content.ReadAsAsync <CreateCardResponse>().Result;

            return(createCardResponse);
        }
 private void AssertResponse(CreateCardCommandResult commandResult, CreateCardResponse response)
 {
     Assert.Equal(commandResult.Id, response.Id);
     Assert.Equal(commandResult.Number, response.Number);
     Assert.Equal(commandResult.CardHolder, response.CardHolder);
     Assert.Equal(commandResult.ExpirationDate, response.ExpirationDate);
 }
        public async Task <IActionResult> Post([FromBody] CreateCardRequest request)
        {
            var command = new CreateCardCommand(request.Number, request.CardHolder, request.ExpirationDate);
            var result  = await commandDispatcher.Dispatch(command);

            if (result.Success)
            {
                var response = new CreateCardResponse()
                {
                    Id             = result.Id,
                    Number         = result.Number,
                    CardHolder     = result.CardHolder,
                    ExpirationDate = result.ExpirationDate
                };

                return(Ok(response));
            }

            return(BadRequest(request));
        }
Beispiel #4
0
        /// <summary>
        /// 获取房卡示例
        /// </summary>
        public void Qrcode()
        {
            CreateCardRequest postEntity = new CreateCardRequest
            {
                communityNo = "1316882760",
                roomNo      = "2108",
                floorNo     = "021",
                buildNo     = "001",
                startTime   = "1911172300",
                endTime     = "1911172330",
                mobile      = "18942040358"
            };

            CreateCardResponse result = LockApiHelper.WebApi.Post <CreateCardRequest, CreateCardResponse>("https://api.uclbrt.com/?c=Qrcode&a=getLink", postEntity);



            string data = LockApiHelper.WebApi.GetCardDataParams("1316882760", "18942040358", "86", result.cardNo);

            // string data = ucl.get("1316879945", "18819238549","86","OxdpqKVrj4VrL2gZ");
            Response.Redirect("http://cz.uclbrt.com/apiLogin?data=" + data);
        }
Beispiel #5
0
        public async Task <CreateCardResponse> CreateCardByDeckId(int deckId, string questionText, string answerText)
        {
            var response = new CreateCardResponse();

            try
            {
                var result = await _baseUrl.AppendPathSegment($"/decks/{deckId}/cards")
                             .WithOAuthBearerToken(_token)
                             .PostJsonAsync(new
                {
                    QuestionText = questionText,
                    AnswerText   = answerText
                });

                response.IsSuccess = result.IsSuccessStatusCode;
            }
            catch (FlurlHttpException e)
            {
                response.Errors = await e.GetResponseJsonAsync <Errors>();
            }

            return(response);
        }
Beispiel #6
0
        public async Task <Result> Handle(AddNewCardCommand request, CancellationToken cancellationToken)
        {
            _logger.LogInformation("Sending card validation request for cardNumber : {cardNumber} with correlation id : {correlationId} to bank ", request.Number, request.CorrelationId);
            var bankResult = await _bankService.ValidateCard(request.Name, request.Number, request.ExpiryMonth,
                                                             request.ExpiryYear, request.Cvv);

            var existingCard = await _cardQuery.GetCardByCardNumberAsync(request.Number);

            if (existingCard != null && existingCard.Cvv == request.Cvv)
            {
                return(Result.Ok());
            }

            if (!bankResult.IsSuccess)
            {
                _logger.LogInformation("Card was flagged invalid by bank for cardNumber : {cardNumber} for correlationid : {correlationId}", request.Number, request.CorrelationId);
                return(Result.Fail <CreateCardResponse>(ExternalErrorReason.CardValidationFailedByBank));
            }
            _logger.LogInformation("card validation request was successful for correlationid : {correlationId}", request.CorrelationId);
            var card = new Domain.Entities.Card(request.Number, request.ExpiryMonth, request.ExpiryYear, request.Name, request.Cvv);

            _cardRepository.Add(card);
            var persistenceResult = await _cardRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);

            if (!persistenceResult.IsSuccess)
            {
                return(Result.Fail <CreateCardResponse>(persistenceResult.Error));
            }

            var successResponse = new CreateCardResponse
            {
                CardToken        = card.CardToken,
                MaskedCardNumber = card.MaskedCardNumber
            };

            return(Result.Ok(successResponse));
        }