/// <summary>
/// Creates a new <see cref="VirgilCard"/> by request.
/// </summary>
/// <param name="request">The request.</param>
public static async Task <VirgilCard> CreateAsync(CreateCardRequest request)
{
var client = VirgilConfig.GetService <VirgilClient>();
var card = await client.CreateCardAsync(request).ConfigureAwait(false);
return(new VirgilCard(card));
}
public async Task <Card> CreateNewCard(CreateCardRequest createCardRequest)
{
var s = await _unitOfWork.GetRepository <Card>().FindAsync(x => x.PatientId == createCardRequest.PatientId);
var p = await _unitOfWork.GetRepository <Patient>().FindAsync(x => x.Id == createCardRequest.PatientId);
if (s != null)
{
throw new Exception("Bệnh nhân đã có thẻ");
}
if (p == null)
{
throw new Exception("Bệnh nhân không tồn tại trong hệ thống");
}
var card = new Card
{
Id = newCardID(),
CardNumber = newCardNumber(),
Money = createCardRequest.Money,
CreatedDate = DateTime.Now,
ExpiredDate = DateTime.Now.AddYears(1),
PatientId = createCardRequest.PatientId,
CreatedBy = createCardRequest.CreatedBy,
Status = 1
};
_unitOfWork.GetRepository <Card>().Add(card);
await _unitOfWork.CommitAsync();
return(card);
}
public async Task Should_Create_User_And_Add_Card()
{
string externalUserId = RandomGenerator.RandomId;
CardInformation cardInformation = CardInformationBuilder
.Create()
.Build();
CreateCardRequest createCardRequest = CreateCardRequestBuilder.Create()
.Card(cardInformation)
.ExternalId(externalUserId)
.Email("*****@*****.**")
.Build();
Card card = await Card.CreateAsync(createCardRequest, Options);
PrintResponse(card);
Assert.AreEqual(Locale.TR.ToString(), card.Locale);
Assert.AreEqual(Status.SUCCESS.ToString(), card.Status);
Assert.NotNull(card.SystemTime);
Assert.AreEqual("123456789", card.ConversationId);
Assert.AreEqual("*****@*****.**", card.Email);
Assert.AreEqual("552879", card.BinNumber);
Assert.AreEqual("card alias", card.CardAlias);
Assert.AreEqual("CREDIT_CARD", card.CardType);
Assert.AreEqual("MASTER_CARD", card.CardAssociation);
Assert.AreEqual("Paraf", card.CardFamily);
Assert.AreEqual("Halk Bankası", card.CardBankName);
Assert.True(card.CardBankCode.Equals(12L));
}
public async Task CreateNewVirgilCard_SignatureValidation_ShouldPassValidation()
{
var crypto = new VirgilCrypto();
var client = IntergrationHelper.GetVirgilClient();
// CREATING A VIRGIL CARD
var appKey = crypto.ImportPrivateKey(IntergrationHelper.AppKey, IntergrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new CreateCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntergrationHelper.AppID, appKey);
var aliceCard = await client.CreateCardAsync(request);
// VALIDATING A VIRGIL CARD
var appPublicKey = crypto.ExtractPublicKey(appKey);
var exportedAppPublicKey = crypto.ExportPublicKey(appPublicKey);
var validator = new CardValidator(crypto);
validator.AddVerifier(IntergrationHelper.AppID, exportedAppPublicKey);
validator.Validate(aliceCard).Should().BeTrue();
await IntergrationHelper.RevokeCard(aliceCard.Id);
}
public async Task CreateNewVirgilCard_IdentityAndPublicKeyGiven_ShouldBeFoundByIdentity()
{
var crypto = new VirgilCrypto();
var client = IntergrationHelper.GetVirgilClient();
var appKey = crypto.ImportPrivateKey(IntergrationHelper.AppKey, IntergrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new CreateCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntergrationHelper.AppID, appKey);
var newCard = await client.CreateCardAsync(request);
var cards = await client.SearchCardsAsync(new SearchCriteria { Identities = new[] { aliceIdentity } });
cards.Should().HaveCount(1);
var foundCard = cards.Single();
newCard.ShouldBeEquivalentTo(foundCard);
}
private static void TryCreatePrefab(CreateCardRequest request, GameObject card)
{
string newPrefabAssetPath = string.Format("Assets/Prefabs/Resources/Cards/{0}/{1}/{2}.prefab",
request.Classification,
request.CardType == Type.Match ? "Matches" : request.CardType + "s",
request.CardName);
if (request.Classification == ClassificationTypes.Character || request.Classification == ClassificationTypes.Adventure)
{
var stringToRemove = request.Classification + "/";
newPrefabAssetPath = newPrefabAssetPath.Replace(stringToRemove, "");
}
if (AssetDatabase.LoadAssetAtPath(newPrefabAssetPath, typeof(GameObject)))
{
string message = string.Format("A prefab already exists at\n{0}\nReplace?", newPrefabAssetPath);
if (EditorUtility.DisplayDialog("Prefab already exists", message, "Yes", "No"))
{
CreatePrefab(newPrefabAssetPath, card);
}
}
else
{
CreatePrefab(newPrefabAssetPath, card);
}
}
public async Task GetSignleVirgilCard_ByGivenId_ShouldReturnVirgilCard()
{
var crypto = new VirgilCrypto();
var client = IntergrationHelper.GetVirgilClient();
var requestSigner = new RequestSigner(crypto);
var appKey = crypto.ImportPrivateKey(IntergrationHelper.AppKey, IntergrationHelper.AppKeyPassword);
// Prepare Requests
var aliceIdentity = "alice-" + Guid.NewGuid();
var aliceKeys = crypto.GenerateKeys();
var alicePublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceRequest = new CreateCardRequest(aliceIdentity, "member", alicePublicKey);
requestSigner.SelfSign(aliceRequest, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(aliceRequest, IntergrationHelper.AppID, appKey);
var aliceCard = await client.CreateCardAsync(aliceRequest);
var foundAliceCard = await client.GetCardAsync(aliceCard.Id);
aliceCard.ShouldBeEquivalentTo(foundAliceCard);
await IntergrationHelper.RevokeCard(aliceCard.Id);
}
public BaseResponse <GetCardResponse> CreateCard(string customerId, CreateCardRequest request)
{
var method = HttpMethod.Post;
var endpoint = $"/customers/{customerId}/cards";
return(this.HttpClientUtil.SendRequest <GetCardResponse>(method, endpoint, request));
}
private static void AddChosenComponents(CreateCardRequest request, GameObject card)
{
if (request.AddLessonRequirement)
{
if (request.CardType == Type.Adventure)
{
var newComponent = card.AddComponent <GenericLessonRequirement>();
newComponent.AmountRequired = request.LessonAmtRequired;
}
else
{
var newComponent = card.AddComponent <LessonRequirement>();
newComponent.AmountRequired = request.LessonAmtRequired;
newComponent.LessonType = request.LessonType;
}
}
if (request.AddCardLimit)
{
var newComponent = card.AddComponent <DeckCardLimitRequirement>();
newComponent.MaximumAmountAllowed = request.MaxAllowedInDeck;
}
if (request.AddExistingScript)
{
var scriptType = request.AttachedScript.GetClass();
var newComponent = (BaseCard)card.AddComponent(scriptType);
newComponent.Classification = request.Classification;
newComponent.Rarity = request.Rarity;
}
}
public async Task Should_Return_CreatedResult_With_Correct_Data()
{
// Arrange
var request = new CreateCardRequest
{
Number = "xxxx-xxxx-xxxx-xxx",
CardHolder = "Filipe A. L. Souza",
ExpirationDate = new DateTime(2022, 1, 12),
};
var commandResult = new CreateCardCommandResult(
id: Guid.NewGuid(),
number: "xxxx-xxxx-xxxx-xxx",
cardHolder: "Filipe A. L. Souza",
expirationDate: new DateTime(2022, 1, 12),
success: true
);
commandDispatcherMock
.Setup(x => x.Dispatch(It.IsAny <CreateCardCommand>()))
.ReturnsAsync(commandResult);
// Act
var actionResult = await sut.Post(request);
// Assert
var createdResult = Assert.IsType <CreatedAtActionResult>(actionResult);
var response = Assert.IsAssignableFrom <CreateCardResponse>(createdResult.Value);
AssertResponse(commandResult, response);
}
public void AlteraCartaoEmAssinatura(string id_Api, CreateCardRequest cartaoApi, string idCartaoDb)
{
try
{
// Secret key fornecida pela Mundipagg
string basicAuthUserName = SistemaSingleton.Instancia.TokenApi;
// Senha em branco. Passando apenas a secret key
string basicAuthPassword = "";
var client = new MundiAPIClient(basicAuthUserName, basicAuthPassword);
var assinaturaApi = new UpdateSubscriptionCardRequest
{
Card = cartaoApi
};
var response = client.Subscriptions.UpdateSubscriptionCard(id_Api, assinaturaApi);
var cartaoDal = new CartaoDal();
cartaoDal.CartaoGravadoNaApiAtualizaBanco(idCartaoDb, response.Card.Id);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private static Material CreateNewMaterial(CreateCardRequest request)
{
string newMaterialAssetPath = string.Format("Assets/Materials/{0}/{1}/{2}Mat.mat",
request.CardType == Type.Match ? "Matches" : request.CardType + "s",
request.Classification,
request.CardName);
if (request.Classification == ClassificationTypes.Character || request.Classification == ClassificationTypes.Adventure)
{
var stringToRemove = request.Classification + "/";
newMaterialAssetPath = newMaterialAssetPath.Replace(stringToRemove, "");
}
var material = new Material(Shader.Find("Diffuse"))
{
mainTexture = request.CardGraphic
};
if (AssetDatabase.GetAllAssetPaths().Contains(newMaterialAssetPath) == false)
{
var path = Path.GetDirectoryName(newMaterialAssetPath);
if (path != null && !Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
AssetDatabase.CreateAsset(material, newMaterialAssetPath);
}
else
{
Debug.LogError(string.Format("Asset at {0} already exists!", newMaterialAssetPath));
return(null);
}
return(material);
}
/// <summary>
/// Converte entidade cartao em modelo de API
/// </summary>
/// <param name="cartao">objeto do cartaoDb</param>
/// <param name="cliente">objeto do clienteDb</param>
/// <returns>requisição CreateCardRequest</returns>
public static CreateCardRequest ConverteNovoCartaoDbEmApi(CartaoDb cartao, ClienteDb cliente)
{
try
{
var createCartao = new CreateCardRequest
{
Number = cartao.Numero_Cartao,
HolderName = cartao.Nome_Cartao,
ExpMonth = cartao.Val_Mes,
ExpYear = cartao.Val_Ano,
Cvv = cartao.Cvc,
BillingAddress = new CreateAddressRequest
{
Line1 = cliente.Endereco_1,
Line2 = cliente.Endereco_2,
ZipCode = cliente.Cep,
City = cliente.Cidade,
State = cliente.Uf,
Country = "BR"
}
};
return(createCartao);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Should_Create_Card()
{
CardInformation cardInformation = new CardInformation();
cardInformation.CardAlias = "myAlias";
cardInformation.CardHolderName = "John Doe";
cardInformation.CardNumber = "5528790000000008";
cardInformation.ExpireMonth = "12";
cardInformation.ExpireYear = "2030";
CreateCardRequest request = new CreateCardRequest();
request.Locale = Locale.TR.GetName();
request.ConversationId = "123456789";
request.CardUserKey = "myCardUserKey";
request.Card = cardInformation;
Card card = Card.Create(request, options);
PrintResponse <Card>(card);
Assert.IsNotNull(card.SystemTime);
Assert.AreEqual(Status.SUCCESS.ToString(), card.Status);
Assert.AreEqual(Locale.TR.GetName(), card.Locale);
Assert.AreEqual("123456789", card.ConversationId);
}
public async Task SearchForVirgilCards_ValidationWithServiceKey_ShouldPassValidation()
{
var crypto = new VirgilCrypto();
var client = IntergrationHelper.GetVirgilClient();
client.SetCardValidator(new CardValidator(crypto));
// CREATING A VIRGIL CARD
var appKey = crypto.ImportPrivateKey(IntergrationHelper.AppKey, IntergrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new CreateCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntergrationHelper.AppID, appKey);
var aliceCard = await client.CreateCardAsync(request);
// VALIDATING A VIRGIL CARD
var cards = await client.SearchCardsAsync(SearchCriteria.ByIdentity(aliceIdentity));
aliceCard.ShouldBeEquivalentTo(cards.Single());
await IntergrationHelper.RevokeCard(aliceCard.Id);
}
private static void CreateCard(CreateCardRequest request)
{
GameObject card = InstantiateCardTemplate();
try
{
card.transform.name = request.CardName;
Material newMaterial = CreateNewMaterial(request);
card.transform.FindChild("Front").gameObject.GetComponent <Renderer>().material = newMaterial;
AddChosenComponents(request, card);
TryCreatePrefab(request, card);
//remove card from scene here
DestroyImmediate(card);
}
catch (Exception e)
{
Debug.Log(string.Format("Error: {0}", e.Message));
Debug.Log("Card was not created");
Destroy(card);
}
}
private async Task <CreateCardResponse> Post(CreateCardRequest request)
{
var response = await controller.Post(request);
var result = Assert.IsType <OkObjectResult>(response);
var data = Assert.IsType <CreateCardResponse>(result.Value);
return(data);
}
public async Task Create(CreateCardRequest request)
{
Card card = new Card();
card.Value = request.Value;
// card.Rank = request.Rank;
// card.Suit = request.Suit;
await _cardRepository.Add(card);
}
private CreateCardRequest GetCreateCardResquest()
{
var request = new CreateCardRequest();
request.CardHolder = "Teste";
request.ExpirationDate = DateTime.Now.Date;
request.Number = "784789407238904742389";
return(request);
}
public async Task <CreateCardResponse> Response(CreateCardRequest @request)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var reqModel = _mapper.Map <CreateCardModel>(@request);
var card = await scope.ServiceProvider.GetRequiredService <ICardService>().CreateCardAsync(reqModel);
return(_mapper.Map <CreateCardResponse>(card));
}
}
public async Task <ActionResult> Create(CreateCardRequest request)
{
if (ModelState.IsValid)
{
await service.CreateCard(request);
return(RedirectToAction("Index"));
}
return(View(request));
}
private async Task <Card> CreateCard()
{
CardInformation cardInformation = CardInformationBuilder.Create()
.Build();
CreateCardRequest cardRequest = CreateCardRequestBuilder.Create()
.Card(cardInformation)
.Email("*****@*****.**")
.Build();
return(await Card.CreateAsync(cardRequest, Options));
}
public CreateCardRequest BuildCardRequest(string identity, string type, Dictionary <string, string> data = null)
{
var crypto = VirgilConfig.GetService <Crypto>();
var signer = VirgilConfig.GetService <RequestSigner>();
var exportedPublicKey = crypto.ExportPublicKey(this.KeyPair.PublicKey);
var request = new CreateCardRequest(identity, type, exportedPublicKey, data);
signer.SelfSign(request, this.KeyPair.PrivateKey);
return(request);
}
private Card CreateCard()
{
CardInformation cardInformation = CardInformationBuilder.Create()
.Build();
CreateCardRequest cardRequest = CreateCardRequestBuilder.Create()
.Card(cardInformation)
.Email("*****@*****.**")
.Build();
return(Card.Create(cardRequest, Options));
}
public async Task SearchForTheVirgilCards_MultipleIdentitiesGiven_ShouldReturnVirgilCards()
{
// Initialization
var crypto = new VirgilCrypto();
var client = IntergrationHelper.GetVirgilClient();
var requestSigner = new RequestSigner(crypto);
var appKey = crypto.ImportPrivateKey(IntergrationHelper.AppKey, IntergrationHelper.AppKeyPassword);
// Prepare Requests
var aliceIdentity = "alice-" + Guid.NewGuid();
var aliceKeys = crypto.GenerateKeys();
var alicePublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var bobIdentity = "bob-" + Guid.NewGuid();
var bobKeys = crypto.GenerateKeys();
var bobPublicKey = crypto.ExportPublicKey(bobKeys.PublicKey);
var aliceRequest = new CreateCardRequest(aliceIdentity, "member", alicePublicKey);
var bobRequest = new CreateCardRequest(bobIdentity, "member", bobPublicKey);
requestSigner.SelfSign(aliceRequest, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(aliceRequest, IntergrationHelper.AppID, appKey);
requestSigner.SelfSign(bobRequest, bobKeys.PrivateKey);
requestSigner.AuthoritySign(bobRequest, IntergrationHelper.AppID, appKey);
// Publish Virgil Cards
var aliceCard = await client.CreateCardAsync(aliceRequest);
var bobCard = await client.CreateCardAsync(bobRequest);
// Search for the Virgil Cards
var foundCards = await client.SearchCardsAsync(new SearchCriteria
{
Identities = new[] { bobIdentity, aliceIdentity }
});
// Assertions
foundCards.Should().HaveCount(2);
foundCards.Single(it => it.Id == aliceCard.Id).ShouldBeEquivalentTo(aliceCard);
foundCards.Single(it => it.Id == bobCard.Id).ShouldBeEquivalentTo(bobCard);
await IntergrationHelper.RevokeCard(aliceCard.Id);
await IntergrationHelper.RevokeCard(bobCard.Id);
}
public CreateCardRequest Build()
{
CreateCardRequest createCardRequest = new CreateCardRequest();
createCardRequest.Locale = _locale;
createCardRequest.ConversationId = _conversationId;
createCardRequest.ExternalId = _externalId;
createCardRequest.Email = _email;
createCardRequest.CardUserKey = _cardUserKey;
createCardRequest.Card = _card;
return(createCardRequest);
}
public async Task Should_Create_Payment_With_Registered_Card()
{
string externalUserId = RandomGenerator.RandomId;
CardInformation cardInformation = CardInformationBuilder.Create()
.Build();
CreateCardRequest cardRequest = CreateCardRequestBuilder.Create()
.Card(cardInformation)
.ExternalId(externalUserId)
.Email("*****@*****.**")
.Build();
Card card = await Card.CreateAsync(cardRequest, Options);
PaymentCard paymentCard = PaymentCardBuilder.Create()
.CardUserKey(card.CardUserKey)
.CardToken(card.CardToken)
.Build();
CreatePaymentRequest request = CreatePaymentRequestBuilder.Create()
.StandardListingPayment()
.PaymentCard(paymentCard)
.Build();
Payment payment = await Payment.CreateAsync(request, Options);
PrintResponse(payment);
Assert.Null(payment.ConnectorName);
Assert.AreEqual(Locale.TR.ToString(), payment.Locale);
Assert.AreEqual(Status.SUCCESS.ToString(), payment.Status);
Assert.NotNull(payment.SystemTime);
Assert.AreEqual("123456789", payment.ConversationId);
Assert.Null(payment.ErrorCode);
Assert.Null(payment.ErrorMessage);
Assert.Null(payment.ErrorGroup);
Assert.NotNull(payment.PaymentId);
Assert.NotNull(payment.BasketId);
Assert.AreEqual("1", payment.Price);
Assert.AreEqual("1.1", payment.PaidPrice);
Assert.AreEqual("0.02887500", payment.IyziCommissionRateAmount);
Assert.AreEqual("0.25000000", payment.IyziCommissionFee);
Assert.AreEqual("10.00000000", payment.MerchantCommissionRate);
Assert.AreEqual("0.1", payment.MerchantCommissionRateAmount);
Assert.AreEqual(0.028875, payment.IyziCommissionRateAmount.ParseDouble());
Assert.AreEqual(0.25, payment.IyziCommissionFee.ParseDouble());
Assert.AreEqual(10, payment.MerchantCommissionRate.ParseDouble());
AssertDecimal.AreEqual(0.02887500M, payment.IyziCommissionRateAmount.ParseDecimal());
AssertDecimal.AreEqual(0.25000000M, payment.IyziCommissionFee.ParseDecimal());
AssertDecimal.AreEqual(10.00000000M, payment.MerchantCommissionRate.ParseDecimal());
Assert.AreEqual(1, payment.Installment);
}
public async Task <CreateCardResponse> Open(Guid id, string userId)
{
var pack = await _packRepository.GetAsync(id);
var request = new CreateCardRequest(userId);
if (pack.Position != null)
{
request.Position = pack.Position;
}
var response = await _bus.RequestAsync <CreateCardRequest, CreateCardResponse>(request);
await _packRepository.Delete(id);
return(response);
}
/// <summary>
/// создание карты
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task CreateCard(CreateCardRequest request)
{
using (var db = new DeckContext())
{
if (long.TryParse(request.SelectedSuitId.ToString(), out long suitId) &&
suitId > 0 &&
long.TryParse(request.SelectedValueId.ToString(), out long valueId) &&
valueId > 0)
{
db.Cards.Add(new Card {
SuitId = suitId, ValueId = valueId
});
await db.SaveChangesAsync();
}
}
}
public static GetCardResponse InitializeCard(JObject data, string customerId, string customerName)
{
string number = (string)data?["cartao"]?["numero"];
int expiration_Month = (int)data?["cartao"]?["expiracao_mes"];
int expiration_Year = (int)data?["cartao"]?["expiracao_ano"];
string cvv = (string)data?["cartao"]?["cvv"];
try
{
var cards = Client.Customers.GetCards(customerId);
var card = cards.Data.Find(c =>
c.FirstSixDigits.Equals(number.Substring(0, 6)) &&
c.LastFourDigits.Equals(number.Substring(number.Length - 4)) &&
c.ExpMonth == expiration_Month &&
c.ExpYear == expiration_Year
);
if (card != null)
{
return(card);
}
var createCard = new CreateCardRequest
{
Number = number,
HolderName = customerName,
ExpMonth = expiration_Month,
ExpYear = expiration_Year,
Cvv = cvv
};
card = Client.Customers.CreateCard(customerId, createCard);
if (string.IsNullOrEmpty(card.Id))
{
throw new InvalidOperationException("Falha em criar o cartão.");
}
return(card);
}
catch (APIException ex)
{
throw new InvalidOperationException("Falha em criar o cartão.", ex);
}
}
