private void insertarTransaccion(Deposito deposito)
{
int tipo = 3;
int n;
using (ATMEntities db = new ATMEntities())
{
Transaccion transaccion = new Transaccion();
transaccion.Fecha = DateTime.Today;
transaccion.Hora = DateTime.Now.TimeOfDay;
transaccion.Tipo = tipo;
transaccion.N_Cuenta = _numeroDeUsuario;
try
{
n = db.Transaccion.Max(p => p.N_Folio);
}
catch (Exception e)
{
n = 1000;
}
transaccion.N_Folio = n + 1;
db.Transaccion.Add(transaccion);
db.Entry(transaccion).State = System.Data.Entity.EntityState.Added;
deposito.N_Folio = transaccion.N_Folio;
db.Deposito.Add(deposito);
db.Entry(deposito).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
}
}
private static void RecordTransaction(
ATMEntities context,
string cardNumber,
decimal amount)
{
using (var tran =
context.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead))
{
try
{
var transactionRecord = new TransactionHistory();
transactionRecord.CardNumber = cardNumber;
transactionRecord.TransactionDate = DateTime.Now;
transactionRecord.Amount = amount;
context.TransactionHistories.Add(transactionRecord);
context.SaveChanges();
tran.Commit();
//Console.WriteLine(accounts.First().CardCash -= amount);
}
catch (Exception e)
{
tran.Rollback();
throw (e);
}
}
}
private String textTransaccion(Transaccion transaccion)
{
/*
* crea el string que tiene los datos de la transaccion
*/
StringBuilder builder = new StringBuilder();
using (ATMEntities db = new ATMEntities())
{
var tiposT = db.Tipo_Transaccion;
if (transaccion.Tipo == 1) //Consulta
{
builder.Append(tiposT.ToArray()[0].Tipo); //se el agrega el nombre de la transaccion
}
else if (transaccion.Tipo == 2)
{
builder.Append(tiposT.ToArray()[1].Tipo); //se el agrega el nombre de la transaccion
Retiro retiro = db.Retiro.Where(p => p.N_Folio == transaccion.N_Folio).FirstOrDefault(); //se obtiene el retiro
builder.Append($" Monto: {retiro.monto}"); //añadimos el monto
}
else if (transaccion.Tipo == 3)
{
builder.Append(tiposT.ToArray()[2].Tipo); //se el agrega el nombre de la transaccion
Deposito deposito = db.Deposito.Where(p => p.N_Folio == transaccion.N_Folio).FirstOrDefault(); // se obtiene el deposito
builder.Append($" N de cuenta: {deposito.N_Cuenta}"); // añadimos la cuenta a la que se le deposito
builder.Append($" Monto: {deposito.monto}"); //añadimos el monto
}
builder.Append(" Fecha: " + transaccion.Fecha + " Hora: " + transaccion.Hora); // añadimos fecha y hora
}
return(builder.ToString()); //regresamos la string
}
/*
* inserta transaccion crea el historial, añade un registro en la tabla transacciones y uno en consulta, retiro o deposito
* dependiendo del caso
*/
private void insertarTransaccion(Consulta consulta)
{
int tipo = 1;
int n;
using (ATMEntities db = new ATMEntities())
{
Transaccion transaccion = new Transaccion();
transaccion.Fecha = DateTime.Today; // obtiene la fecha actual
transaccion.Hora = DateTime.Now.TimeOfDay; // hora de la transaccion
transaccion.Tipo = tipo;
transaccion.N_Cuenta = _numeroDeUsuario;
try
{
n = db.Transaccion.Max(p => p.N_Folio);
}
catch (Exception e)
{
n = 1000;
}
transaccion.N_Folio = n + 1;
db.Transaccion.Add(transaccion);
db.Entry(transaccion).State = System.Data.Entity.EntityState.Added;
consulta.N_Folio = transaccion.N_Folio;
db.Consulta.Add(consulta);
db.Entry(consulta).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
}
}
private int cantidadDepositos(int mes)
{
using (ATMEntities db = new ATMEntities())
{
var n = db.Transaccion.Count(p => p.Tipo == 3 && p.Fecha.Value.Month == mes); //cantida de depositos del mes seleccionado
return(n);
}
}
private static void FillNewDataInTransactionHistory(ATMEntities context, string cardNumber, decimal money)
{
context.TransactionHistories.Add(
new TransactionHistory()
{
CardNumber = cardNumber, TransactionDate = DateTime.Now, Amount = money
});
context.SaveChanges();
}
public static void WithdrawMoney(
ATMEntities context,
string cardNumber,
string cardPin,
decimal amount)
{
using (var tran =
context.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead))
{
try
{
if (cardNumber.Length != 10 || cardPin.Length != 4 || amount <= 0)
{
throw new ArgumentException
("Some of the arguments passed are invalid");
}
var accounts = context.CardAccounts.Where(a => a.CardNumber == cardNumber);
if (accounts == null)
{
throw new ArgumentException("No such card in database");
}
if (accounts.Count() > 1)
{
throw new ArgumentException("Database contains more than one card" +
" with such number");
}
if (accounts.First().CardCash < amount)
{
throw new InvalidOperationException("Not enough cash in account");
}
if (accounts.First().CardPIN != cardPin)
{
throw new ArgumentException("Invalid PIN");
}
var account = accounts.First();
account.CardCash = account.CardCash - amount;
context.SaveChanges();
tran.Commit();
RecordTransaction(context, cardNumber, amount);
}
catch (Exception e)
{
tran.Rollback();
throw (e);
}
}
}
private void guardarCambios() //guarda el saldo actual
{
using (ATMEntities db = new ATMEntities())
{
Cliente cliente = db.Cliente.Where(d => d.N_Cuenta == _numeroDeUsuario).FirstOrDefault();
cliente.Saldo = _saldo; // actualiza el saldo
db.Entry(cliente).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
static void Main(string[] args)
{
var db = new ATMEntities();
var cardAccounts = db.CardAccounts;
foreach (var cardAccount in cardAccounts)
{
Console.WriteLine(cardAccount.CardCash);
WithdrawalMoney(cardAccount.CardNumber,cardAccount.CardPin, 2000);
}
}
static void Main()
{
var context = new ATMEntities();
string cardNumber = "6598956359";
string pinNumber = "9896";
decimal amount = 20m;
TransactionUtilities.WithdrawMoney(context, cardNumber, pinNumber, amount);
var remainingAmount = context.CardAccounts
.Where(c => c.CardNumber == cardNumber)
.Select(c => c.CardCash).First();
Console.WriteLine(remainingAmount);
}
private static void SaveTransactionHistory(string cardNumber, decimal amount)
{
var db = new ATMEntities();
var newTransaction = new TransactionHistory()
{
CardNumber = cardNumber,
TransactionDate = DateTime.Now,
Amount = amount
};
db.TransactionHistories.Add(newTransaction);
db.SaveChanges();
}
private void historialClienteMes(int mes, int n)
{
using (ATMEntities db = new ATMEntities())
{
var histTrans = db.Transaccion.Where(p => p.N_Cuenta == n && p.Fecha.Value.Month == mes);
Console.WriteLine($"Mes: {mes}");
foreach (var x in histTrans)
{
Console.WriteLine(textTransaccion(x));
}
Console.ReadLine();
}
}
private int cantidadDineroDepositos(int mes)
{
int dinero = 0;
using (ATMEntities db = new ATMEntities())
{
var n = db.Transaccion.Where(p => p.Tipo == 3 && p.Fecha.Value.Month == mes && p.N_Cuenta == _numeroDeUsuario);
foreach (var x in n)
{
dinero += Convert.ToInt32(db.Deposito.Where(P => P.N_Folio == x.N_Folio).FirstOrDefault().monto); //cantida de dinero de depositos del mes seleccionado
}
}
return(dinero);
}
private void depositarCliente(int numCuenta, int monto)
{
/*
* Le suma el monto al saldo del cliente con el Numero de cuenta igual al especificado (numCuenta)
*/
using (ATMEntities db = new ATMEntities())
{
Cliente cliente = db.Cliente.Where(d => d.N_Cuenta == numCuenta).FirstOrDefault();
cliente.Saldo = cliente.Saldo + monto;
db.Entry(cliente).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
private bool revisarExistenciaCliente(int n)
{
// regresa True si existe el cliente y False en caso contrario
using (ATMEntities db = new ATMEntities())
{
Cliente cliente = db.Cliente.Where(d => d.N_Cuenta == n).FirstOrDefault();
if (cliente != null)
{
return(true);
}
else
{
return(false);
}
}
}
private bool Cliente_o_Gerente()
{
//determina si el usuario es cliente o gerente (no se toma en cuenta el caso de una cuenta que sea los 2)
using (ATMEntities db = new ATMEntities())
{
Cliente cliente = db.Cliente.Where(d => d.N_Cuenta == _numeroDeUsuario).FirstOrDefault(); //revisa si existe el cliente
if (cliente != null) // si existe, entonces es cliente
{
_saldo = Convert.ToInt32(cliente.Saldo);
return(true); // cliente
}
else // no existe en la tabla clientes por lo que es gerente
{
return(false); //gerente
}
}
}
private void historialClienteMes(int mes)
{
/*
* Imprime las transacciones
*/
using (ATMEntities db = new ATMEntities())
{
var histTrans = db.Transaccion.Where(p => p.N_Cuenta == _numeroDeUsuario && p.Fecha.Value.Month == mes); // transacciones del usuario en el mes indicado
Console.WriteLine($"Mes: {mes}");
foreach (var x in histTrans)
{
Console.WriteLine(textTransaccion(x)); // imprime la transaccion con los datos
}
Console.ReadLine();
}
}
private static void ATMWithdrawWithHystory(ATMEntities context, int userId)
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
var account = context.CardAccounts.Find(userId);
try
{
var givenAccount = context.CardAccounts
.Where(a => a.CardNumber == account.CardNumber && a.CardPIN == account.CardPIN);
foreach (var acc in givenAccount)
{
Console.Write("Enter card number: ");
string card = Console.ReadLine();
Console.Write("Enter PIN: ");
string pin = Console.ReadLine();
if (card != acc.CardNumber || pin != acc.CardPIN)
{
throw new Exception("Invalid card number or PIN");
}
Console.Write("Enter sum: ");
decimal sum = decimal.Parse(Console.ReadLine());
if (acc.CardCash < sum)
{
throw new Exception("Available cash is not enough to commit transaction");
}
acc.CardCash -= sum;
var note = new TransactionHistory()
{
CardNumber = card,
TransactionDate = DateTime.Now,
Amount = sum
};
context.TransactionHistories.Add(note);
}
context.SaveChanges();
dbContextTransaction.Commit();
Console.WriteLine("Transaction has been commited");
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
Console.WriteLine("Error: " + ex.Message);
}
}
}
private bool verificar()
{
Usuario usuario;
using (ATMEntities db = new ATMEntities())
{
Encrypt encrypt = new Encrypt(); // esta clase encripta por medio de md5 para comparar las contraseñas
usuario = db.Usuario.Where(d => d.N_Cuenta == _numeroDeUsuario).FirstOrDefault(); //regresa el usuario si existe
if (usuario != null)
{
if (encrypt.EncryptPass(_NIP).Equals(encrypt.byteToString(usuario.NIPP))) //compara contraseñas encriptadas
{
return(true); //VALIDO
}
}
}
return(false); //INVALIDO
}
public static void WithdrawMoney(string cardNumber, string cardPin, decimal money)
{
var context = new ATMEntities();
using (var dbContextTransaction = context.Database.BeginTransaction(IsolationLevel.RepeatableRead))
{
try
{
if (cardNumber.Length != 10 || cardPin.Length != 4)
{
throw new InvalidOperationException("Invalid length of CardNumber or CardPin");
}
var accountCard =
context.CardAccounts.FirstOrDefault(ac => ac.CardNumber == cardNumber);
if (accountCard == null)
{
throw new ArgumentNullException("There isn't account with such card number in the database.");
}
if (accountCard.CardPIN != cardPin)
{
throw new ArgumentException("The entered PIN number is wrong");
}
if (accountCard.CardCash < money)
{
throw new InvalidOperationException("You are trying to withdraw more than available money.");
}
accountCard.CardCash -= money;
context.SaveChanges();
dbContextTransaction.Commit();
FillNewDataInTransactionHistory(context, accountCard.CardNumber, money);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw ex;
}
}
}
private static void WithdrawalMoney(string cardNumber, string cardPin, decimal amount)
{
var db = new ATMEntities();
using (var dbContextTransaction = db.Database.BeginTransaction())
{
try
{
var account = db.CardAccounts
.FirstOrDefault(a => a.CardNumber == cardNumber);
if (account == null)
{
var messge = string.Format("Invalid card number: {0}", cardNumber);
throw new ArgumentException(messge);
}
if (account.CardPin!= cardPin)
{
var messge = string.Format("Invalid pin number: {0}", cardPin);
throw new ArgumentException(messge);
}
if (account.CardCash < amount)
{
var messge = string.Format("Not enough amount of money!\nAvailability: {0}", account.CardCash);
throw new ArgumentException(messge);
}
account.CardCash = account.CardCash - amount;
db.SaveChanges();
dbContextTransaction.Commit();
SaveTransactionHistory(cardNumber, amount);
Console.WriteLine("Withdrawal is successfull.\nRemaining amount: {0}", account.CardCash);
}
catch (ArgumentException ae)
{
dbContextTransaction.Rollback();
Console.WriteLine("Error: " + ae.Message);
}
}
}
private void verSaldo()
{
Consulta consulta = new Consulta(); //crea consulta para el historial
using (ATMEntities db = new ATMEntities())
{
int n;
try
{
n = db.Consulta.Max(p => p.id_Consulta);
}catch (Exception e)
{
n = 1000;
}
consulta.id_Consulta = n + 1;
}
insertarTransaccion(consulta); // inserta la consulta en el historial
Console.WriteLine("Saldo: {0}", _saldo);
Console.ReadKey();
}
static void Main()
{
//Problem 5. Transactional ATM Withdrawal
//Using transactional logic in Entity Framework write a method that withdraws money (for example $200) from given account.
//The withdrawal is successful when the following steps are completed successfully:
//Step 1. Check if the given CardPIN and CardNumber are valid. Throw an exception if not.
//Step 2. Check if the amount on the account (CardCash) is bigger than the requested sum (in our example $200).
//Throw an exception if not.
//Step 3. The ATM machine pays the required sum (e.g. $200)
//and stores in the table CardAccounts the new amount (CardCash = CardCash - 200).
//Put the above steps in explicit transaction that is started before the first step and is committed after the last step.
var context = new ATMEntities();
//ATMWithdraw(context, 1);
//Problem 6. ATM Transactions History
//Extend the project from the previous exercise and add a new table TransactionHistory
//with fields (Id, CardNumber, TransactionDate, Amount) holding information about all money withdrawals on all accounts.
//Modify the withdrawal logic so that it preserves history in the new table after each successful money withdrawal.
ATMWithdrawWithHystory(context, 7);
}
private void retirarDinero()
{
int opc; //opcion seleccionada
int cantidadRetirar = 0;
bool repetir = false, opcValida = true;
do
{
repetir = false;
opcValida = true;
Console.Clear();
Console.WriteLine(" 1) $20 \n 2) $40 \n 3) $60 \n 4) $100 \n 5) $200 \n 6) salir");
opc = int.Parse(Console.ReadLine());
switch (opc)
{
case 1:
case 2:
case 3:
cantidadRetirar = 20 * opc;
repetir = false;
break;
case 4:
cantidadRetirar = 100;
repetir = false;
break;
case 5:
cantidadRetirar = 200;
repetir = false;
break;
case 6:
return;
default:
Console.WriteLine("Opcion invalida...");
Console.ReadKey();
repetir = true;
opcValida = false;
break;
}
if (opcValida)
{
if (cantidadRetirar > _saldo) // revisa que la cantidad sea mayor al saldo
{
Console.WriteLine("Saldo insuficiente...");
Console.ReadKey();
repetir = true;
}
else if ((cantidadRetirar / 20) > _billetesDe20) // revisa que el cajero tenga billetes
{
Console.WriteLine("Cantidad de billetes insuficientes...");
Console.ReadKey();
repetir = true;
}
else if (opcValida)
{
repetir = false;
}
else
{
repetir = true;
}
}
} while (repetir);
//correcto
Retiro retiro = new Retiro(); // crea retiro para el historial
using (ATMEntities db = new ATMEntities())
{
int n;
try
{
n = db.Retiro.Max(p => p.id_Retiro);
}
catch (Exception e)
{
n = 1000;
}
retiro.id_Retiro = n + 1;
retiro.monto = cantidadRetirar;
}
insertarTransaccion(retiro);// inserta el retiro en el historial
_saldo -= cantidadRetirar;
_billetesDe20 -= (cantidadRetirar / 20);
guardarCambios(); //actualizamos el archivo
Console.WriteLine("Recoja su dinero...");
Console.ReadKey();
}
private void depositarDinero()
{
int monto; //deposito
int numeroDeCuentaDeposito;
bool repetirUsuario = false;
do
{
repetirUsuario = false;
Console.Clear();
Console.WriteLine("Introdusca el numero de cuenta al que le va a depositar o 0 para salir: ");
numeroDeCuentaDeposito = Convert.ToInt32(Console.ReadLine());
if (numeroDeCuentaDeposito == 0)
{
return;
}
else if (!revisarExistenciaCliente(numeroDeCuentaDeposito))
{
Console.WriteLine("No existe esa cuenta...");
Console.ReadLine();
repetirUsuario = true;
}
} while (repetirUsuario);
Console.WriteLine("Introdusca el monto o 0 para salir: ");
monto = int.Parse(Console.ReadLine());
if (monto == 0)
{
return;
}
monto = monto / 100; //monto real
for (int i = 0; i < 1200; i++) //2 min
{
Thread.Sleep(100);
if (Console.KeyAvailable)
{
//si se pulsa una tecla en menos de 2 min
if (numeroDeCuentaDeposito == _numeroDeUsuario)
{
_tempSaldo += monto;
}
else //se separa ya que si el usuario se deposita a el mismo no podra ver el cambio hasta salir de la sesion
{
depositarCliente(numeroDeCuentaDeposito, monto);
}
Deposito deposito = new Deposito(); //crea deposito para el historial
using (ATMEntities db = new ATMEntities())
{
int n;
try
{
n = db.Deposito.Max(p => p.id_Deposito);
}
catch (Exception e)
{
n = 1000;
}
deposito.id_Deposito = n + 1;
deposito.monto = monto;
deposito.N_Cuenta = numeroDeCuentaDeposito;
}
insertarTransaccion(deposito);// inserta el deposito en el historial
Console.WriteLine("Listo :) \n pulsa enter");
Console.ReadKey();
Console.ReadLine();
return;
}
}
//ya pasaron 2 min
Console.WriteLine("cancelado por inactividad...");
Console.ReadKey();
}