static void Main(string[] args)
{
IFactory factory = null;
IPayment payment = null;
ConsoleKey keyPressed;
do
{
Console.Clear();
Console.WriteLine("Ingrese una opción: [C] Credit Card [P] PayPal [W] WireTransfer [Esc] Salir");
keyPressed = Console.ReadKey(true).Key;
switch (keyPressed)
{
case ConsoleKey.C:
factory = new CreditCardFactory();
break;
case ConsoleKey.P:
factory = new PaypalFactory();
break;
case ConsoleKey.W:
factory = new WireTransferFactory();
break;
default:
return;
}
payment = factory.CreatePayment();
ProcessPayment(payment);
} while (keyPressed != ConsoleKey.Escape);
}
public void test_credit_card()
{
// MoneyBack card
{
CreditCard creditCard = CreditCardFactory.GetCreditCard(CreditCardType.MoneyBack);
Assert.That(creditCard.GetCardType() == CreditCardType.MoneyBack);
Assert.That(creditCard.GetAnnualCharge() == 20000);
Assert.That(creditCard.GetCreditLimit() == 1000);
}
// Platium card
{
CreditCard creditCard = CreditCardFactory.GetCreditCard(CreditCardType.Platium);
Assert.That(creditCard.GetCardType() == CreditCardType.Platium);
Assert.That(creditCard.GetAnnualCharge() == 30000);
Assert.That(creditCard.GetCreditLimit() == 1500);
}
// Titanium card
{
CreditCard creditCard = CreditCardFactory.GetCreditCard(CreditCardType.Titanium);
Assert.That(creditCard.GetCardType() == CreditCardType.Titanium);
Assert.That(creditCard.GetAnnualCharge() == 35000);
Assert.That(creditCard.GetCreditLimit() == 2000);
}
}
public OperationDetails Create(CreditCardDTO card, string userId)
{
List <CreditCard> c = Database.CardRepository.Find(x => x.Number == card.Number).ToList();
if (c.Count == 0)
{
DateTime expiration = new DateTime(
Convert.ToInt32("20" + card.Year),
Convert.ToInt32(card.Month), 1);
if (expiration < DateTime.Now)
{
return(new OperationDetails(false, "Your card is expired", ""));
}
var hash = Database.UserManager.PasswordHasher.HashPassword(card.SecurityCode);
CreditCard creditCard = CreditCardFactory.CreateCreditCard(card, hash, userId);
if (creditCard != null)
{
Database.CardRepository.Create(creditCard);
Database.CardRepository.SaveChanges();
return(new OperationDetails(true, "Card added successfully", ""));
}
return(new OperationDetails(false, "Card number is incorrect", "Number"));
}
return(new OperationDetails(false, "Card already exists", ""));
}
public async Task EditAsync(CreditCardEditModel model)
{
var creditCard = await _creditCardRepository.GetAsync(model.Id);
CreditCardFactory.Create(model, creditCard, _userId);
_creditCardRepository.Edit(creditCard);
await _unitOfWork.SaveChangesAsync();
}
public ActionResult <string> Post([FromBody] string customerId)
{
var cardNumber = CreditCardFactory.RandomCardNumber(CardIssuer.MasterCard);
//var card = CashCardDomain.CashCard.CreateCashCard()
return(cardNumber);
}
static void Main(string[] args)
{
var keepGoing = true;
Console.WriteLine("Enter individual credit card numbers at the prompt:");
Console.WriteLine("Enter 'f' to enter an input file name:");
Console.WriteLine("Enter 'x' to exit:");
ICreditCardValidator validator = new LuhnValidator();
ICreditCardFactory factory = new CreditCardFactory(validator, CARDDEFINITIONS);
while (keepGoing)
{
Console.Write("Enter card number > ");
var cardNumber = Console.ReadLine();
if (cardNumber == "x")
{
keepGoing = false;
}
else if (cardNumber == "f")
{
Console.Write("Enter a file name of credit card numbers > ");
var filename = Console.ReadLine();
if (!File.Exists(filename))
{
Console.WriteLine("File does not exist: " + filename);
}
else
{
try
{
using (StreamReader sr = new StreamReader(filename))
{
while ((cardNumber = sr.ReadLine()) != null)
{
CreditCard card = factory.CreateCreditCard(cardNumber);
var result = card.ToString();
Console.WriteLine(result);
}
}
}
catch (Exception e)
{
Console.WriteLine("The file could not be read:");
Console.WriteLine(e.Message);
}
}
}
else
{
CreditCard card = factory.CreateCreditCard(cardNumber);
var result = card.ToString();
Console.WriteLine(result);
}
}
}
public static void GeneratePII(string filename, string type)
{
//Number of PII to generate
int gensize = 10000;
List <string> piidata = new List <string>();
switch (type)
{
case "creditcard":
if (File.Exists(filename))
{
for (int i = 0; i < gensize; i++)
{
piidata.Add((string)CreditCardFactory.RandomCardNumber(CardIssuer.Visa));
}
using (StreamWriter sw = File.AppendText(filename))
{
foreach (var card in piidata)
{
sw.WriteLine(card);
}
}
}
else
{
Console.WriteLine("File does not exist");
}
break;
case "ssn":
if (File.Exists(filename))
{
Random generator = new Random();
for (int i = 0; i < gensize; i++)
{
piidata.Add(Regex.Replace(String.Format("{0:###-##-####}", generator.Next(0, 999999999).ToString("D9")), @"^(.{3})(.{2})(.{4})$", "$1-$2-$3"));
}
using (StreamWriter sw = File.AppendText(filename))
{
foreach (var card in piidata)
{
sw.WriteLine(card);
}
}
}
else
{
Console.WriteLine("File does not exist");
}
break;
default:
Console.WriteLine("Please specify type of PII to generate. Current supported types are creditcard and ssn");
break;
}
}
private static async void OptionScreen1(IEndpointInstance endpointInstance)
{
WriteChooseOption();
Console.WriteLine("1.Request a virtual cash card");
Console.WriteLine("2.Insert a virtual cash card");
Console.WriteLine("Press Esc to exit");
Console.WriteLine();
while (true)
{
var auditInfo = new AuditInfo {
By = "login User", Created = DateTime.UtcNow
};
var key = Console.ReadKey();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.Escape:
break;
case ConsoleKey.D1:
_currentCardNumber.Number = String.Empty;
var message = new RequestCashCard(auditInfo, CreditCardFactory.RandomCardNumber(CardIssuer.MasterCard), "1");
Console.WriteLine($"card has been requested and will virtual be posted");
await endpointInstance.Send("CashCard.Service", message).ConfigureAwait(false);
Console.WriteLine($"waiting for card ...");
while (true)
{
if (_currentCardNumber.Number != message.CardNumber)
{
continue;
}
Console.WriteLine($"received cash card {message.CardNumber} and inserting ...");
break;
}
InsertCard(endpointInstance, _currentCardNumber.Number);
break;
case ConsoleKey.D2:
//read Card
if (String.IsNullOrEmpty(_currentCardNumber.Number))
{
Console.WriteLine("Enter the card number");
_currentCardNumber.Number = Console.ReadLine();
}
InsertCard(endpointInstance, _currentCardNumber.Number);
break;
default:
Console.WriteLine("Please select correct option");
break;
}
}
}
static void AbstractFactoryPatternTest()
{
CreditCardFactory abstractFactory = CreditCardFactory.GetCreditCardFactory(600);
CreditCard creditCard = abstractFactory.GetCreditCard(CardType.GOLD);
Console.WriteLine(creditCard.GetType());
abstractFactory = CreditCardFactory.GetCreditCardFactory(700);
creditCard = abstractFactory.GetCreditCard(CardType.PLATINUM);
Console.WriteLine(creditCard.GetType());
}
public void TestUnknownCardIssuerGeneration()
{
for (int i = 0; i < 10000; i++)
{
var unkCard = CreditCardFactory.RandomCardNumber(CardIssuer.Unknown);
CreditCardDetector detector = new CreditCardDetector(unkCard);
detector.Brand.ShouldBe <CardIssuer>(CardIssuer.Unknown);
}
}
public async Task <int> Handle(Command request, CancellationToken cancellationToken)
{
Domain.Models.CuentaBancaria bankAccount = new Domain.Models.CuentaBancaria()
{
IdUser = request.IdUser,
Pin = request.Pin,
NCuenta = CreditCardFactory.RandomCardNumber(CardIssuer.Visa, 16)
};
bankAccount = await _repository.CreateAccountAsync(bankAccount);
return(bankAccount.Id);
}
public override IWallet GetWallet(params ICardType[] cardTypes)
{
var wallet = new MockWallet();
foreach (var cardType in cardTypes)
{
var card = CreditCardFactory.GetCreditCard(cardType);
wallet.CreditCards.Add(card);
}
return(wallet);
}
public void Test2()
{
var person = new Person();
person.AddWallet();
person.ContainedWallets[0].AddCard(CreditCardFactory.CreateCard <VisaBaseCreditCard>(100));
person.ContainedWallets[0].AddCard(CreditCardFactory.CreateCard <DiscoverBaseCreditCard>(100));
person.AddWallet();
person.ContainedWallets[1].AddCard(CreditCardFactory.CreateCard <MCBaseCreditCard>(100));
Assert.AreEqual((decimal)16, person.DetermineTotalInterestNextIncrement());
Assert.AreEqual((decimal)11, person.ContainedWallets[0].DetermineTotalInterestNextIncrement());
Assert.AreEqual((decimal)5, person.ContainedWallets[1].DetermineTotalInterestNextIncrement());
}
private void OnOrderSubmitted(object sender, EventArgs e)
{
new Action <string, OrderRequest>(SendRequest).BeginInvoke($"/orders/order", new OrderRequest()
{
Id = Guid.NewGuid(),
Product = ((ProductDetail)cbProducts.SelectedItem).Id,
Address = "Unit 1, 100 John Street, Sydney",
Quantity = rnd.Next(1, 9),
Payment = CreditCardFactory.RandomCardNumber((CardIssuer)Enum.Parse(typeof(CardIssuer), cbPayment.SelectedItem.ToString())),
Zip = GetZip(cbArea.SelectedItem.ToString()),
Country = "Australia"
}, null, null);
}
public void Test2(string cardType)
{
var cardDetails = CreditCardFactory.GetCreditCard(cardType);
if (string.IsNullOrEmpty(cardType))
{
Assert.True(cardDetails is null);
}
else
{
Assert.False(cardDetails is null);
Assert.Contains(cardType.ToLower(), cardDetails.GetCardType().ToLower());
}
}
public void TestVersion05()
{
CreditCardFactory abstractFactory = CreditCardFactory.GetCreditCardFactory(775);
CreditCard card = abstractFactory.GetCreditCard(CardType.PLATINUM);
Debug.WriteLine(card.GetType());
abstractFactory = CreditCardFactory.GetCreditCardFactory(600);
CreditCard card2 = abstractFactory.GetCreditCard(CardType.GOLD);
Debug.WriteLine(card2.GetType());
}
public void GivenACardIssuer_RandomCardNumber_ReturnsAValidCard(CardIssuer cardIssuer)
{
// Arrange.
// Act.
var number = CreditCardFactory.RandomCardNumber(cardIssuer);
// Assert.
var detector = new CreditCardDetector(number);
detector.Brand.ShouldBe(cardIssuer);
detector.IsValid(cardIssuer).ShouldBe(true);
detector.IsValid().ShouldBe(true);
}
static void Main(string[] args)
{
CreditCard cardDetails = CreditCardFactory.GetCreditCard("Platinum");
if (cardDetails != null)
{
Console.WriteLine("CardType : " + cardDetails.GetCardType());
Console.WriteLine("CreditLimit : " + cardDetails.GetCreditLimit());
Console.WriteLine("AnnualCharge :" + cardDetails.GetAnnualCharge());
}
else
{
Console.Write("Invalid Card Type");
}
Console.ReadLine();
}
public void GivenACardIssuer_RandomCardNumber_ReturnsAValidCard_Length_MaxLength(CardIssuer cardIssuer)
{
// Arrange.
var maxLength = TestHelperUtilities.Lengths(cardIssuer).Last();
// Act.
var number = CreditCardFactory.RandomCardNumber(cardIssuer, maxLength);
// Assert.
var detector = new CreditCardDetector(number);
number.Length.ShouldBe(maxLength);
detector.Brand.ShouldBe(cardIssuer);
detector.IsValid(cardIssuer).ShouldBe(true);
detector.IsValid().ShouldBe(true);
}
public void Test3()
{
var person1 = new Person();
var person2 = new Person();
person1.AddWallet();
person1.ContainedWallets[0].AddCard(CreditCardFactory.CreateCard <MCBaseCreditCard>(100));
person1.ContainedWallets[0].AddCard(CreditCardFactory.CreateCard <VisaBaseCreditCard>(100));
person2.AddWallet();
person2.ContainedWallets[0].AddCard(CreditCardFactory.CreateCard <VisaBaseCreditCard>(100));
person2.ContainedWallets[0].AddCard(CreditCardFactory.CreateCard <MCBaseCreditCard>(100));
Assert.AreEqual((decimal)15, person1.DetermineTotalInterestNextIncrement());
Assert.AreEqual((decimal)15, person2.DetermineTotalInterestNextIncrement());
Assert.AreEqual((decimal)15, person1.ContainedWallets[0].DetermineTotalInterestNextIncrement());
Assert.AreEqual((decimal)15, person2.ContainedWallets[0].DetermineTotalInterestNextIncrement());
}
internal static void Call()
{
Console.WriteLine("Factory Pattern");
CreditCard cardDetails = CreditCardFactory.GetCreditCard(CreditCardType.MoneyBack);
if (cardDetails != null)
{
Console.WriteLine("CardType : " + cardDetails.GetCardType());
Console.WriteLine("CreditLimit : " + cardDetails.GetCreditLimit());
Console.WriteLine("AnnualCharge :" + cardDetails.GetAnnualCharge());
}
else
{
Console.Write("Invalid Card Type");
}
}
public void GivenACardIssuer_RandomCardNumber_ReturnsAValidCard_Length_MinLength(CardIssuer cardIssuer)
{
// Arrange.
var lengths = TestHelperUtilities.Lengths(cardIssuer);
foreach (var len in lengths)
{
// Act.
var number = CreditCardFactory.RandomCardNumber(cardIssuer, len);
// Assert.
var detector = new CreditCardDetector(number);
number.Length.ShouldBe(len);
detector.Brand.ShouldBe(cardIssuer);
detector.IsValid(cardIssuer).ShouldBe(true);
detector.IsValid().ShouldBe(true);
}
}
public static void GenCard()
{
Console.WriteLine("Do you want to Generate a Visa Credit Card Number? Y/N");
var answer = "n";
string number = "";
answer = Console.ReadLine();
if (answer == "y" || answer == "Y")
{
number = CreditCardFactory.RandomCardNumber(CardIssuer.Visa);
Console.WriteLine(number);
Console.ReadLine();
}
else
{
Console.WriteLine("No selected, no Credit Card Number will be generated");
}
return;
}
public void GivenACardIssuer_RandomCardNumber_ReturnsAValidCard_Length_Invalid(CardIssuer cardIssuer)
{
// Arrange.
string number = "";
Exception e = new Exception();
// Act.
try
{
number = CreditCardFactory.RandomCardNumber(cardIssuer, 99);
}
catch (Exception ex)
{
e = ex;
}
// Assert
e.ShouldBeOfType <ArgumentException>();
e.Message.ShouldBe("99 is not valid length for card issuer " + cardIssuer.ToString());
number.Length.ShouldBe(0);
}
public void GivenACardIssuer_RandomCardNumber_ReturnsAValidCard_Length_Invalid(CardIssuer cardIssuer)
{
// Arrange.
string number = "";
Exception e = new Exception();
int length = 99;
// Act.
try
{
number = CreditCardFactory.RandomCardNumber(cardIssuer, length);
}
catch (Exception ex)
{
e = ex;
}
// Assert
e.ShouldBeOfType <ArgumentException>();
e.Message.ShouldBe($"The card number length [{length}] is not valid for the card issuer [{cardIssuer}].");
number.Length.ShouldBe(0);
}
public void TestMultiThreadRandomCardNumberGeneration()
{
var tasks = new List <Task>();
var results = new ConcurrentDictionary <string, byte>();
for (int i = 0; i < 20; i++)
{
var task = new Task(() =>
{
for (int j = 0; j < 1000; j++)
{
var cardNumber = CreditCardFactory.RandomCardNumber(CardIssuer.MasterCard);
Assert.NotNull(cardNumber);
Assert.True(results.TryAdd(cardNumber, 0), $"Error: Factory generated a duplicated card number: [{cardNumber}]");
}
});
tasks.Add(task);
}
tasks.ForEach(t => t.Start());
Task.WaitAll(tasks.ToArray());
}
public CreditCardBuilder(CreditCardFactory cardFactory) : base(cardFactory)
{
}
private string GenerateCreditCardNumber(string issuer)
{
return(CreditCardFactory.RandomCardNumber((CardIssuer)Enum.Parse(typeof(CardIssuer), issuer)));
}
/// <summary>
/// Provides a Valid VISA card number.
/// </summary>
/// <returns></returns>
private string GetValidCardNumber()
{
return(CreditCardFactory.RandomCardNumber(CardIssuer.Visa));
}
public async Task AddAsync(CreditCardAddModel model)
{
await _creditCardRepository.AddAsync(CreditCardFactory.Create(model, _userId));
await _unitOfWork.SaveChangesAsync();
}
