public static decimal RetriveSomeMoney(string cardNumber, string cardPin, decimal amount)
{
ATMEntities dbATM = new ATMEntities();
var transOption = new TransactionOptions();
transOption.IsolationLevel = IsolationLevel.RepeatableRead;
var scope = new TransactionScope(TransactionScopeOption.RequiresNew, transOption);
using (scope)
{
foreach (var account in dbATM.CardAccounts)
{
if ((account.CardNumber == cardNumber) && (account.CardPIN == cardPin) && (account.CardCash > amount))
{
account.CardCash -= amount;
var log = new TransactionHistory()
{
CardNumber = cardNumber,
TransactionDate = DateTime.Now,
Amount = amount
};
dbATM.TransactionHistories.Add(log);
dbATM.SaveChanges();
scope.Complete();
return(amount);
}
}
}
return(-1);
}
public ActionResult Withdraw(TransactionModel model)
{
if (ModelState.IsValid && model.debit > 0)
{
string dtStamp = DateTime.Now.ToString();
var balance = getAccountBalance(model.account);
if (balance <= model.debit)
{
TempData["successW"] = "N";
}
else
{
var dbATM = new ATMEntities();
var transaction = new transaction
{
tStamp = dtStamp,
debit = model.debit,
account = model.account,
credit = 0
};
dbATM.transactions.AddObject(transaction);
dbATM.SaveChanges();
TempData["successW"] = "Y";
}
return(View(model));
}
else
{
ModelState.AddModelError("", "The withdrawal value provided is incorrect.");
}
return(View(model));
}
public static void insertTrunsaction(DateTime starttime, DateTime endtime, decimal withdrow)
{
db = new ATMEntities();
int id = rnd.Next(1, 21);
var atm = db.ATMs.Where(x => x.id == id).FirstOrDefault();
if (atm.balance > withdrow)
{
atm.balance -= withdrow;
Models.Trunsaction trunsaction = new Models.Trunsaction()
{
atm_id = id,
start_time = starttime,
end_time = endtime,
withdrow = withdrow
};
try
{
db.Trunsactions.Add(trunsaction);
db.SaveChanges();
}
catch (Exception)
{
db = null;
}
//count_trunsaction_day(id);
DateTime date1 = DateTime.Now;
DateTime date2 = date1.AddHours(-1);
trunsaction_Between_date(id, date2, date1);
}
db = null;
}
public static void DepositMoney(decimal amount, string cardNumber, string cardPin)
{
if (cardNumber.Length != 10 || cardPin.Length != 4)
{
throw new ArgumentException("Card {0} has invalid length", cardPin.Length == 4 ? "Number" : "Pin");
}
using (var db = new ATMEntities())
{
using (var tran = db.Database.BeginTransaction(IsolationLevel.RepeatableRead))
{
var card = db.CardAccounts.Where(c => c.Number == cardNumber).FirstOrDefault();
if (card == null)
{
throw new ArgumentException("Card with this number does not exist");
}
if (card.Pin != cardPin)
{
throw new ArgumentException("Incorect Pin number");
}
if (amount < 0 && card.Cash < (-1) * amount)
{
throw new ArgumentException("Not enough cash");
}
card.Cash += amount;
if (InteractWithMoney(amount))
{
db.TransactionsHistories.Add(new TransactionsHistory()
{
Amount = amount,
CardNumber = cardNumber,
TransactionDate = DateTime.Now
});
try
{
db.SaveChanges();
tran.Commit();
Console.WriteLine("Success");
}
catch (Exception ex)
{
tran.Rollback();
throw ex;
}
}
else
{
tran.Rollback();
throw new ArgumentException("Something is wrong with the ATM machine");
}
}
}
}
public void ATMDatabaseHistoryShoudWithdrawMoney()
{
ATMHistory.WithdrawMoney(cardNumber, cardPin, 100M);
var testContext = new ATMEntities();
var newCash = testContext.CardAccounts.First(c => c.CardNumber == cardNumber).CardCach;
Assert.AreEqual(900M, newCash);
}
public bool UpdatePin(long cardNumber, int oldPin, int newPin)
{
using (var dbContext = new ATMEntities())
{
var effectedRows = dbContext.UpdateCardDetails(1, cardNumber, oldPin, newPin, null);
return(effectedRows > 0);
}
}
public bool WithdrawBalance(long cardNumber, int pin, long newBalance)
{
using (var dbContext = new ATMEntities())
{
var effectedRows = dbContext.UpdateCardDetails(2, cardNumber, pin, null, newBalance);
return(effectedRows > 0);
}
}
static void RetrieveMoney(decimal amount, string cardNumber, string cardPin)
{
if (cardNumber == null)
{
throw new ArgumentNullException("cardNumber", "Provided card number cannot be null!");
}
if (cardPin == null)
{
throw new ArgumentNullException("cardPIN", "Provided card PIN cannot be null!");
}
if (cardNumber.Length != 10)
{
throw new ArgumentException(
"Provided card number is invalid! Card number must consist of 10 digits!");
}
if (cardPin.Length != 4)
{
throw new ArgumentException(
"Provided card PIN is invalid! Card PIN must consist of 4 digits!");
}
using (var scope = new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions()
{
IsolationLevel = IsolationLevel.RepeatableRead
}))
{
using (var atmContext = new ATMEntities())
{
var cardAccount = atmContext.CardAccounts.FirstOrDefault(
ca => ca.CardNumber.CompareTo(cardNumber) == 0 &&
ca.CardPIN.CompareTo(cardPin) == 0);
if (cardAccount == null)
{
scope.Dispose();
throw new TransactionException(
"There is no card account with provided card number and PIN!");
}
if (cardAccount.CardCash < amount)
{
scope.Dispose();
throw new TransactionException(
"There is no enough money in the account to retrive the requested amount!");
}
cardAccount.CardCash -= amount;
atmContext.SaveChanges();
}
scope.Complete();
}
}
public static void insert_into_atm_amount(int atmid, int amount)
{
db = new ATMEntities();
var c = db.ATMs.Where(i => i.id == atmid).FirstOrDefault();
c.balance += amount;
db.SaveChanges();
db = null;
}
public void ATMDatabaseHistoryShoudWithdrawMoneyAndSaveHistory()
{
ATMHistory.WithdrawMoney(cardNumber, cardPin, 100M);
var testContext = new ATMEntities();
var newCash = testContext.CardAccounts.First(c => c.CardNumber == cardNumber).CardCach;
var newCashTransaction = testContext.TransactionHistories.OrderBy(c => c.TransactionDate).First(c => c.CardNumber == cardNumber).Amount;
Assert.AreEqual(900M, newCash);
Assert.AreEqual(900M, newCashTransaction);
}
private static bool CheckIsHasMoney(ATMEntities context, string cardNumber, decimal money)
{
var currentEntity = context.CardAccounts.First(c => c.CardNumber == cardNumber);
if (currentEntity.CardCach >= money)
{
return(true);
}
throw new Exception("You do not have enough money!");
}
public bool ValidateCardNumber(long cardNumber)
{
using (var dbContext = new ATMEntities())
{
var result = dbContext.ValidateCardDetails(1, cardNumber, Pin);
{
var effectedRows = dbContext.ValidateCardNumber(cardNumber);
return(false);
}
}
}
public bool ValidatePin(long cardNumber, int pin)
{
using (var dbContext = new ATMEntities())
{
var result = dbContext.ValidateCardDetails(2, cardNumber, pin).GetEnumerator();
while (result.MoveNext())
{
return(result.Current > 0);
}
}
return(false);
}
private static void MoneyWithdraw()
{
var context = new ATMEntities();
using (var dbContextTransaction = context.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead))
{
try
{
Console.WriteLine("Enter valid PIN");
string cardPin = Console.ReadLine();
Console.WriteLine("Enter valid Card Number");
string cardNumber = Console.ReadLine();
Console.WriteLine("Enter amount of money to withdrawal");
decimal withdrawalMoney = decimal.Parse(Console.ReadLine());
if (cardPin.Length != 4 || cardNumber.Length != 10 || withdrawalMoney < 0)
{
throw new ArgumentException("The requested arguments are with not valid length or are null");
}
var allAccounts = context.CardAccounts;
if (allAccounts.All(c => c.CardPIN != cardPin))
{
throw new ArgumentException("Invalid PIN !");
}
if (allAccounts.All(c => c.CardNumber != cardNumber))
{
throw new ArgumentException("Invalid Card Number !");
}
var account = context.CardAccounts
.Where(c => c.CardNumber == cardNumber);
if (withdrawalMoney > account.First().CardCash)
{
throw new ArgumentException("Not enough money in account");
}
account.First().CardCash -= withdrawalMoney;
context.SaveChanges();
dbContextTransaction.Commit();
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
Console.WriteLine("Error: " + ex.Message);
}
}
}
private static bool CheckIsValid(ATMEntities context, string cardNumber, string pinNumber)
{
try
{
var currentEntity = context.CardAccounts.First(c => c.CardNumber == cardNumber && c.CardPIN == pinNumber);
}
catch (Exception)
{
throw new Exception("You're entering a wrong card number or PIN!");
}
return(true);
}
static void Main()
{
var context = new ATMEntities();
string cardNumber = String.Empty;
decimal amountToWithdraw = 0;
var accountToWithdraw = context.CardAccounts.Find(1);
var threwException = false;
// Unfinished!
while (true)
{
try
{
Console.WriteLine("Please enter the card number: ");
cardNumber = Console.ReadLine();
Console.WriteLine("Please enter the card PIN: ");
string cardPin = Console.ReadLine();
Console.WriteLine("Please enter the amount to withdraw: ");
amountToWithdraw = decimal.Parse(Console.ReadLine());
if (amountToWithdraw > accountToWithdraw.CardCash || accountToWithdraw.CardCash == null)
{
throw new ArgumentOutOfRangeException(
"You cannot withdraw more cash than what you currently have: " + accountToWithdraw.CardCash);
}
using (var transaction = context.Database.BeginTransaction())
{
}
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine(ex.Message);
threwException = true;
}
if (!threwException)
{
context.TransactionHistories.Add(new TransactionHistory()
{
CardNumber = cardNumber,
Amount = amountToWithdraw,
TransactioDate = DateTime.Now
});
}
}
}
////public static int count_trunsaction_day(int atmid)
//{
// db = new ATMEntities();
// //List<Trunsaction> z = db.Trunsactions.Where(i => i.atm_id == atmid && i.start_time.Value.ToShortDateString()==DateTime.Today.ToShortDateString()).ToList();
// //int y = z.Count;
// List<Trunsaction> t = db.Trunsactions.Where(i=>i.atm_id==atmid).ToList();
// int x = t.Count;
// var atm = db.ATMs.Where(i => i.id == atmid).FirstOrDefault();
// atm.T_N = x;
// //atm.T_N_last_day = y;
// db.SaveChanges();
// oldcount = x - oldcount;
// db = null;
// return oldcount;
//}
public static void trunsaction_Between_date(int atmid, DateTime starttime, DateTime endtime)
{
db = new ATMEntities();
List <Trunsaction> q = db.Trunsactions.Where(i => i.atm_id == atmid).ToList();
int y = q.Count;
List <Trunsaction> t = q.Where(i => i.start_time >= starttime && i.start_time < endtime).ToList();
int x = t.Count;
var atm = db.ATMs.Where(i => i.id == atmid).FirstOrDefault();
atm.T_N = y;
atm.T_N_last_hour = x;
db.SaveChanges();
db = null;
//return 1;
}
static void Main(string[] args)
{
var random = RandomDataGenerator.Instance;
var db = new ATMEntities();
var listOfGenerators = new List<IDataGenerator>
{
new CardNumberDataGenerator(random, db, 100),
};
foreach (var generator in listOfGenerators)
{
generator.Generate();
db.SaveChanges();
}
}
private double getAccountBalance(string account)
{
var balance = 0.0;
using (ATMEntities db = new ATMEntities())
{
var trans = from t in db.transactions
where t.account == account
select t;
foreach (transaction tran in trans)
{
balance += (tran.credit - tran.debit);
}
}
return(balance);
}
static void Main(string[] args)
{
var random = RandomDataGenerator.Instance;
var db = new ATMEntities();
var listOfGenerators = new List <IDataGenerator>
{
new CardNumberDataGenerator(random, db, 100),
};
foreach (var generator in listOfGenerators)
{
generator.Generate();
db.SaveChanges();
}
}
public static void Main()
{
// First run "14.Transactions-in-ADO.NET-and-EF.sql"
// If don't work, check the connection string!!!
TransactionOptions transactionOptions = new TransactionOptions()
{
IsolationLevel = IsolationLevel.RepeatableRead
};
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew, transactionOptions))
{
ATMEntities db = new ATMEntities();
string pin = GetPIN();
string cardNumber = GetCardNumber();
decimal money = GetMoney();
var userAccount = db.CardAccounts.Where(x => x.CardPIN == pin && x.CardNumber == cardNumber).FirstOrDefault();
if (userAccount == null)
{
Console.WriteLine("Incorrect PIN or card number!");
return;
}
if (userAccount.CardCash > money)
{
userAccount.CardCash = userAccount.CardCash - 200;
db.TransactionsHistories.Add(new TransactionsHistory
{
Ammount = money,
CardNumber = cardNumber,
TransactionDate = DateTime.Now
});
Console.WriteLine(userAccount.CardCash);
db.SaveChanges();
Console.WriteLine("Please take {0} money!", money);
}
else
{
Console.WriteLine("Not enough money!");
}
scope.Complete();
}
}
private static CardAccount InputCardNumber(ATMEntities context)
{
Console.Write("--Please, enter your card number: ");
var candidateCardNumber = Console.ReadLine();
var cardFound = context.CardAccounts
.FirstOrDefault(ca => ca.CardNumber.Equals(candidateCardNumber));
if (cardFound == null)
{
throw new InvalidOperationException("--Card number is invalid. Please enter a correct one.");
}
Console.WriteLine("--Card number exists.");
Console.Write("--Insert the PIN of the selected card: ");
return cardFound;
}
// **************************************
// URL: /Transaction/Balance
// **************************************
public ActionResult Balance(string userName = "")
{
if (userName != "")
{
var accountNumber = "";
var oldUser = MembershipService.GetUser(userName, false);
var userID = oldUser.ProviderUserKey.ToString();
List <TransactionModel> trans = new List <TransactionModel> {
};
using (ATMEntities db = new ATMEntities())
{
var customer = from c in db.customers
where c.idCustomer == userID
select c;
accountNumber = customer.Single().account;
var dbtrans = from t in db.transactions
where t.account == accountNumber
select t;
var balance = getAccountBalance(accountNumber);
foreach (transaction dbtran in dbtrans)
{
TransactionModel tempInstance = new TransactionModel();
tempInstance.account = dbtran.account;
tempInstance.debit = Convert.ToSingle(dbtran.debit);
tempInstance.credit = Convert.ToSingle(dbtran.credit);
tempInstance.tStamp = dbtran.tStamp;
trans.Add(tempInstance);
}
Session.Add("accountNumber", accountNumber);
TempData["balance"] = balance;
return(View(trans));
}
}
else
{
return(View());
}
}
public void AddNewAccount(long cardNumber, string name, int pin, long balance)
{
ATM atmObject = null;
using (var dbContext = new ATMEntities())
{
var results = dbContext.spNewAccount(cardNumber, name, pin, balance).GetEnumerator();
while (results.MoveNext())
{
var result = results.Current;
atmObject = new ATM();
atmObject.CardNumber = result.CardNumber;
atmObject.Name = result.Name;
atmObject.Pin = result.Pin;
//atmObject.Cvv = result.Cvv;
atmObject.CurrentBalance = result.CurrentBalance.Value;
}
}
}
public ATM GetAtmDetails(long cardNumber, int pin)
{
ATM atmObject = null;
using (var dbContext = new ATMEntities())
{
var res = dbContext.GetCardDetails(cardNumber, pin).GetEnumerator();
while (res.MoveNext())
{
var result = res.Current;
atmObject = new ATM();
atmObject.CardNumber = result.CardNumber;
atmObject.Name = result.Name;
atmObject.Pin = result.Pin;
atmObject.Cvv = result.Cvv;
atmObject.CurrentBalance = result.CurrentBalance.Value;
}
}
return(atmObject);
}
static void Main()
{
Console.Write("Enter Card Number: ");
string cardNum = Console.ReadLine();
Console.Write("PIN: ");
string pin = Console.ReadLine();
Console.Write("Amount of money to withdrawal: ");
decimal withdrawaledMoney = decimal.Parse(Console.ReadLine());
var ctx = new ATMEntities();
using (var dbContextTransaction = ctx.Database.BeginTransaction(IsolationLevel.RepeatableRead))
{
var card = ctx.CardAccounts.FirstOrDefault(a => a.CardNumber == cardNum);
if (card == null || card.CardPIN != pin)
{
dbContextTransaction.Rollback();
throw new Exception("Invalid input data.");
}
decimal moneyAfterWithdrawal = card.CardCash - withdrawaledMoney;
if (moneyAfterWithdrawal < 0)
{
dbContextTransaction.Rollback();
throw new Exception("Insufficient amount of money.");
}
card.CardCash = moneyAfterWithdrawal;
ctx.TransactionHistories.Add(new TransactionHistory()
{
CardNumber = card.CardNumber,
TransactionDate = DateTime.Now,
Amount = withdrawaledMoney
});
ctx.SaveChanges();
dbContextTransaction.Commit();
}
}
public static void SeedData()
{
using (var db = new ATMEntities())
{
if (db.CardAccounts.FirstOrDefault() == null)
{
return;
}
for (int i = 0; i < 25; i++)
{
db.CardAccounts.Add(new CardAccount()
{
Cash = 10000,
Number = new string(i.ToString()[0], 10),
Pin = new string(i.ToString()[0], 4)
});
}
db.SaveChanges();
}
}
static void Main()
{
Console.Write("Enter Card Number: ");
string cardNum = Console.ReadLine();
Console.Write("PIN: ");
string pin = Console.ReadLine();
Console.Write("Amount of money to withdrawal: ");
decimal withdrawaledMoney = decimal.Parse(Console.ReadLine());
var ctx = new ATMEntities();
using (var dbContextTransaction = ctx.Database.BeginTransaction(IsolationLevel.RepeatableRead))
{
var card = ctx.CardAccounts.FirstOrDefault(a => a.CardNumber == cardNum);
if (card == null || card.CardPIN != pin)
{
dbContextTransaction.Rollback();
throw new Exception("Invalid input data.");
}
decimal moneyAfterWithdrawal = card.CardCash - withdrawaledMoney;
if(moneyAfterWithdrawal < 0)
{
dbContextTransaction.Rollback();
throw new Exception("Insufficient amount of money.");
}
card.CardCash = moneyAfterWithdrawal;
ctx.TransactionHistories.Add(new TransactionHistory()
{
CardNumber = card.CardNumber,
TransactionDate = DateTime.Now,
Amount = withdrawaledMoney
});
ctx.SaveChanges();
dbContextTransaction.Commit();
}
}
protected override void Seed(ATM.Data.ATMEntities context)
{
var ctx = new ATMEntities();
var random = new Random();
if (ctx.CardAccounts.Count() == 0)
{
for (var i = 0; i < 10; i++)
{
var randomCardNumber = random.Next(1000000000).ToString().PadLeft(10, '0');
var randomCardPIN = random.Next(10000).ToString().PadLeft(4, '0');
var randomBalance = (decimal)(random.Next(100000) + 100);
ctx.CardAccounts.Add(new CardAccount()
{
CardNumber = randomCardNumber,
CardPIN = randomCardPIN,
CardCash = randomBalance
});
}
}
ctx.SaveChanges();
}
public ActionResult Deposit(TransactionModel model)
{
if (ModelState.IsValid && model.credit > 0)
{
string dtStamp = DateTime.Now.ToString();
var dbATM = new ATMEntities();
var transaction = new transaction
{
tStamp = dtStamp,
credit = model.credit,
account = model.account,
debit = 0
};
dbATM.transactions.AddObject(transaction);
dbATM.SaveChanges();
TempData["successD"] = "Y";
}
else
{
ModelState.AddModelError("", "The deposit value provided is incorrect.");
}
return(View(model));
}
public void InitializeContext()
{
context = new ATMEntities();
cardNumber = "3333333333";
cardPin = "3333";
money = 1000M;
countEntity = context.CardAccounts.Count(c => c.CardNumber == cardNumber);
if (countEntity == 0)
{
context.CardAccounts.Add(new CardAccount()
{
CardNumber = cardNumber,
CardPIN = cardPin,
CardCach = money
});
context.SaveChanges();
}
else
{
context.CardAccounts.First(c => c.CardNumber == cardNumber).CardCach = money;
context.SaveChanges();
}
}
public static void WithdrawMoney(string cardNumber, string pinNumber, decimal money)
{
using (var context = new ATMEntities())
{
using (var dbContextTransaction = context.Database.BeginTransaction(IsolationLevel.RepeatableRead))
{
try
{
if (CheckIsValid(context, cardNumber, pinNumber))
{
if (CheckIsHasMoney(context, cardNumber, money))
{
var currentEntity = context.CardAccounts.First(c => c.CardNumber == cardNumber && c.CardPIN == pinNumber);
var historyEntity = context.TransactionHistories;
currentEntity.CardCach = currentEntity.CardCach - money;
historyEntity.Add(new TransactionHistory()
{
CardNumber = currentEntity.CardNumber,
TransactionDate = DateTime.Now,
Amount = currentEntity.CardCach
});
context.SaveChanges();
Console.WriteLine("You have got your money!Amount after withdraw {0}!", currentEntity.CardCach);
}
}
dbContextTransaction.Commit();
}
catch (Exception e)
{
dbContextTransaction.Rollback();
Console.WriteLine("Transaction cancled!\nError Occured: {0}", e.Message);
}
}
}
}
public static void Main()
{
var context = new ATMEntities();
while (true)
{
try
{
// Card number: 0963596714
// Card PIN: 7206
// Read and validate Card Number and Card PIN
var cardFound = InputCardNumber(context);
InputCardPIN(cardFound);
// Read the amount of money and withdraw them
Console.Write("--Insert the amount you want to withdraw: ");
var amountToWithdraw = decimal.Parse(Console.ReadLine());
Withdraw(amountToWithdraw, cardFound);
// Adding transaction history entry.
context.TransactionHistoryEntries.Add(new TransactionHistoryEntry
{
CardNumber = cardFound.CardNumber,
TransactionDate = DateTime.Now,
Amount = amountToWithdraw
});
Console.Write("--Created transaction history log.");
context.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
FormsService.SignIn(model.UserName, false);
var accountNumber = "";
var oldUser = MembershipService.GetUser(model.UserName, false);
var userID = oldUser.ProviderUserKey.ToString();
using (ATMEntities db = new ATMEntities())
{
var customer = from c in db.customers
where c.idCustomer == userID
select c;
accountNumber = customer.Single().account;
}
Session.Add("accountNumber", accountNumber);
if (!String.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
return(View(model));
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus = MembershipService.CreateUser(model.UserName, model.Password, model.Email);
if (createStatus == MembershipCreateStatus.Success)
{ // On success create a new customer data
MembershipUser newUser = MembershipService.GetUser(model.UserName, false);
string newUserID = newUser.ProviderUserKey.ToString();
string dtStamp = DateTime.Now.ToString();
string accountNo = Guid.NewGuid().ToString();
var dbATM = new ATMEntities();
var customer = new customer
{
idCustomer = newUserID,
firstName = model.FirstName,
lastName = model.LastName,
account = accountNo,
cDate = dtStamp
};
dbATM.customers.AddObject(customer);
dbATM.SaveChanges();
FormsService.SignIn(model.UserName, false);
Session.Add("accountNumber", accountNo);
TempData["justRegistered"] = "Y";
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", CustomerValidation.ErrorCodeToString(createStatus));
}
}
ViewData["PasswordLength"] = MembershipService.MinPasswordLength;
return(View(model));
}
public DataGenerator(IRandomDataGenerator randomDataGenerator, ATMEntities atmEntities, int countGeneratedObjects)
{
this.random = randomDataGenerator;
this.db = atmEntities;
this.count = countGeneratedObjects;
}
public CardNumberDataGenerator(IRandomDataGenerator randomDataGenerator, ATMEntities atmEntities, int countGeneratedObjects)
: base(randomDataGenerator, atmEntities, countGeneratedObjects)
{
}