コード例 #1
0
        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();
            }
        }
コード例 #2
0
        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);
                }
            }
        }
コード例 #3
0
        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
        }
コード例 #4
0
        /*
         * 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();
            }
        }
コード例 #5
0
 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);
     }
 }
コード例 #6
0
 private static void FillNewDataInTransactionHistory(ATMEntities context, string cardNumber, decimal money)
 {
     context.TransactionHistories.Add(
         new TransactionHistory()
     {
         CardNumber = cardNumber, TransactionDate = DateTime.Now, Amount = money
     });
     context.SaveChanges();
 }
コード例 #7
0
        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);
                }
            }
        }
コード例 #8
0
 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();
     }
 }
コード例 #9
0
ファイル: Program.cs プロジェクト: Bare7a/Software-University
 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);
     }
 }
コード例 #10
0
        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);
        }
コード例 #11
0
ファイル: Program.cs プロジェクト: Bare7a/Software-University
        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();
        }
コード例 #12
0
        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();
            }
        }
コード例 #13
0
        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);
        }
コード例 #14
0
        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();
            }
        }
コード例 #15
0
 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);
         }
     }
 }
コード例 #16
0
 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
         }
     }
 }
コード例 #17
0
        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();
            }
        }
コード例 #18
0
 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);
         }
     }
 }
コード例 #19
0
        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
        }
コード例 #20
0
        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;
                }
            }
        }
コード例 #21
0
ファイル: Program.cs プロジェクト: Bare7a/Software-University
        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);
                }
            }
        }
コード例 #22
0
        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();
        }
コード例 #23
0
        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);
        }
コード例 #24
0
        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();
        }
コード例 #25
0
        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();
        }