Exemplo n.º 1
0
        //************************************************************************************************************************************************
        public static void ReWriteBankLinkedList( )
        //************************************************************************************************************************************************
        {
            // iterate thru bankaccount objects and add threm to our linkedList
            string dir = BankAccount.ReadBankFilePath( );

            string[] files = System.IO.Directory.GetFiles(dir, "*.bnk");
            // iterate thru all the files on disk, startinmg at 1
            // Iterate trhu them and handle as required
            int count = 0;

            foreach (var fi in files)
            {
                bool result = fi.Contains("BankObject");
                if (!result)
                {
                    continue;
                }
                {
                    using
                        BankAccount B = (BankAccount)SerializeData.ReadBankAccountFromDisk(fi);

                    // As we have red it in, we need to delete it so we do not
                    // duplicate it when saving all files at end of a user sessoin.
                    if (B != null)
                    {
                        BankAccount.BankAccountsLinkedList.AddLast(B);     // Add this one to our linked list of customers.
                        BankTransaction newbankaccount = new BankTransaction(B.DateOpened, B.AccountType, B.CustAccountNumber,
                                                                             B.BankAccountNumber, B.Balance, "Customer account updated successfuly", B.Status);
                        BankTransaction.allBankTransactions.AddLast(newbankaccount);
                    }
                    count++;
                }
            }
            // save linked list to disk in text format
            Lists.SaveAllBankAccountListData( );
        }
Exemplo n.º 2
0
        // Save the new customer data as an Object and add it to the Customer List
        // plus create a BankAccount object and add it to the BankAccount List
        // and add a bak transaction
        //*************************************************************************************************************************************************//
        private void SaveBankButton_Click(object sender, EventArgs e)
        //*************************************************************************************************************************************************//
        {
            if (AccountNo.Text.Length == 0 || AccountBalance.Text.Length == 0 || Interest.Text.Length == 0 || OpenDate.Text.Length == 0 || fname.Text.Length == 0 ||
                lname.Text.Length == 0 || day.Text.Length == 0 || month.Text.Length == 0 || year.Text.Length == 0)
            {
                MessageBox.Show("One or more fields are empty, All fields must be populated", "User Input Error");
                return;
            }
            Int16 type = 0;

            if (AccountType.Text.Contains("Normal"))
            {
                type = 1;
            }
            if (AccountType.Text.Contains("Savings"))
            {
                type = 2;
            }
            if (AccountType.Text.Contains("Deposit"))
            {
                type = 3;
            }
            if (AccountType.Text.Contains("Business"))
            {
                type = 4;
            }

            //====================BANK ACCOUNT ========================================
            // READ BANK OBJECT FROM DISK and update it
            // Bank should be valid as it is a global in this file ?
            if (allbankaccounts.SelectedIndex == -1)
            {
                MessageBox.Show("The Bank Account list does not appear to have an item selected\nWe No data has been changed, but we are UNABLE to continue with update...", "Database system ERROR");
                return;
            }
            string target = allbankaccounts.Items[allbankaccounts.SelectedIndex].ToString();

            char[]   ch        = { '\t' };
            char[]   dashch    = { '-' };
            string[] tempacno  = target.Split(ch);
            Int32    accountno = Convert.ToInt32(tempacno[0]);

            Bank = Search.FindBankObjectfromBankNo(accountno);
            int    actype         = Convert.ToInt16(AccountType.SelectedIndex + 1);
            string actypeselected = AccountType.SelectedItem.ToString();

            string[] newselaccount = actypeselected.Split(dashch);
            if (newselaccount[0] != tempacno[1])
            {   // the type of account has been changed - handle it
                for (int i = 0; i < allbankaccounts.Items.Count; i++)
                {
                    string temp = "";
                    temp = allbankaccounts.Items[i].ToString();
                    string[] thisentry = temp.Split(ch);
                    if (thisentry[0] == tempacno[0] && thisentry[1] != newselaccount[0])
                    {
                        listupdateneeded = false;   //This simply avoids the auto update of the listbox, set back to true afterwards
                        allbankaccounts.Items.RemoveAt(i);
                        temp = Bank.BankAccountNumber.ToString() + "\t" + actype.ToString();
                        allbankaccounts.Items.Add(temp);
                        allbankaccounts.SelectedIndex = i;
                        listupdateneeded = true;
                        break;
                    }
                }
            }
            // Thkis call sends Event data to Bankaccount.cs so the handlers can handle it
            // cos we cannot call them directly in BankAccount.cs
            BankAccount.SendBankEventData(Bank, "BANKACCOUNT MODIFIED");

            // we need to  delete the old account and insert the new details  in our ArrayList
            int index = DataArray.ArrayFindBank(Bank);

            DataArray.BankNo.RemoveAt(index);
            BankAccount.BankDict.Remove(index);

            Bank.Balance      = Convert.ToDecimal(AccountBalance.Text);
            Bank.InterestRate = Convert.ToDecimal(Interest.Text);
            Bank.DateOpened   = Convert.ToDateTime(OpenDate.Text);
            Bank.AccountType  = Convert.ToInt16(actype);
            //SAVE BANK OBJECT BACK TO DISK
            SerializeData.WriteBankAccountToDiskAndText(Bank, Bank.FullFileName);
            DataArray.ArrayAddBank(Bank);
            if (BankAccount.BankDict != null)
            {
                if (!BankAccount.BankDict.ContainsKey(Bank.BankAccountNumber))
                {
                    BankAccount.BankDict.Add(Bank.BankAccountNumber, Bank);
                }
            } // handle the Linkedlist as well

            // CREATE A NEW BANK TRANSACTION
            BankTransaction newbankaccount = new BankTransaction();

            newbankaccount.TransDate         = DateTime.Now;
            newbankaccount.AccountType       = Bank.AccountType;
            newbankaccount.CustAccountNumber = Bank.CustAccountNumber;
            newbankaccount.BankAccountNumber = Bank.BankAccountNumber;
            newbankaccount.Transamount       = Bank.Balance;
            newbankaccount.Notes             = "Opening Balance";
            newbankaccount.Status            = Bank.Status;
            BankTransaction.allBankTransactions.AddLast(newbankaccount);
            //Update the Customer HASH TABLE
            CustomerBalanceHashTable.UpdateCustBalHashTable(Bank.CustAccountNumber.ToString(), Bank.Balance);

            //NOW UPDATE CUSTOMER RECORD
            Cust = Customer.GetCustomerAccount(Bank.CustAccountNumber.ToString());
            if (Cust == null)
            {
                MessageBox.Show("Unable to find the Customer Record from LinkedList", "Database system ERROR"); return;
            }
            else
            {
                // we need to  delete the old Customer account and insert the new details  in our ArrayList
                int indx = DataArray.ArrayFindCust(Cust);
                DataArray.CustNo.RemoveAt(indx);
                Customer.CustDict.Remove(indx);
                // Now update the Customer record so we can add it to the array
                Cust.FirstName = fname.Text;
                Cust.LastName  = lname.Text;
                Cust.DOB       = Convert.ToDateTime(day.Text + "/" + month.Text + "/" + year.Text);
                if (Cust.accountnums[0] == Convert.ToInt32(Bank.BankAccountNumber))
                {
                    Cust.accounttypes[0] = type;
                }
                else if (Cust.accountnums[1] == Convert.ToInt32(Bank.BankAccountNumber))
                {
                    Cust.accounttypes[1] = type;
                }
                else if (Cust.accountnums[2] == Convert.ToInt32(Bank.BankAccountNumber))
                {
                    Cust.accounttypes[2] = type;
                }
                else if (Cust.accountnums[3] == Convert.ToInt32(Bank.BankAccountNumber))
                {
                    Cust.accounttypes[3] = type;
                }
                Cust.Address1     = addr1.Text;
                Cust.Address2     = addr2.Text;
                Cust.Town         = town.Text;
                Cust.County       = county.Text;
                Cust.PostCode     = postcode.Text;
                Cust.PhoneNumber  = phone.Text;
                Cust.MobileNumber = mobile.Text;

                // SAVE CUSTOMER OBJECT BACK TO DISK
                Customer.WriteCustObjectToDiskAndText(Cust, Cust.FullFileName);
                try
                {   // update Customer Linked List & ArrayList
                    Customer.CustomersLinkedList.Remove(Cust);
                    Customer.CustomersLinkedList.AddLast(Cust);
                    // save our Customer LinkedList to disk as binary and txt files
                    Lists.SaveAllCustomerListData(Customer.CustomerFilePath + "CustSortedListData.cust");
                    DataArray.ArrayAddCust(Cust);
                    if (Customer.CustDict != null)
                    {
                        if (!Customer.CustDict.ContainsKey(Cust.CustomerNumber))
                        {
                            Customer.CustDict.Add(Cust.CustomerNumber, Cust);
                        }
                    }
                }
                catch { new Exception("Customer Linked List coukld not be updated in bankaccountEdit.cs cline 103"); }
            }

            MessageBox.Show("Bank & Customer  accounts have been updated successfully...,", "Bank account Edit Facility");
        }
Exemplo n.º 3
0
        //=========================================================================//
        //EXTERNAL
        public Int16 LoadArraysFromDisk(out int Bcount, out int Ccount)
        //=========================================================================//
        {
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // We iterate through all Bank .BNK files cos we can also read the relevant
            // Customer #  from it, and then load that to the Customer array - Clever eh ?
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            Int16 count = 0;

            Bcount = 0;
            Ccount = 0;
            Int32[] custno     = new int[100];
            int     custcount  = 0;
            bool    duplicated = false;
            // start with BankAccounts
            string dir  = BankAccount.ReadBankFilePath();
            string dir2 = Customer.GetCustFilePath();

            string[] bankfiles = System.IO.Directory.GetFiles(dir, "Bankobject*.bnk");
            // initilaize our check array
            for (int i = 0; i < 100; i++)
            {
                custno[i] = 0;
            }
            // Iterate trhu them and handle as required
            foreach (var fi in bankfiles)
            {
                bool result = fi.Contains("BankObject");
                if (result)
                {
                    // Got a bank account object
                    BankAccount B = (BankAccount)SerializeData.ReadBankAccountFromDisk(fi);
                    if (B != null)
                    {
                        DataArray.ArrayAddBank(B);     // Add to bank ArrayList
                        if (BankAccount.BankDict != null)
                        {
                            if (!BankAccount.BankDict.ContainsKey(B.BankAccountNumber))
                            {
                                BankAccount.BankDict.Add(B.BankAccountNumber, B);
                            }
                        }
                        Bcount++;
                        BankAccount.BankAccountsLinkedList.AddLast(B);
                        Customer C = (Customer)SerializeData.ReadCustomerDiskObject(dir2 + "Custobj" + B.CustAccountNumber + ".cust");
                        if (C != null)
                        {
                            // add to our test array
                            // check to see if it has been added before ?
                            for (int i = 0; i < custcount; i++)
                            {
                                if (custno[i] == C.CustomerNumber)
                                {
                                    duplicated = true;
                                    break;
                                }
                            }
                            custno[custcount++] = C.CustomerNumber;
                            if (!duplicated)
                            {
                                DataArray.ArrayAddCust(C);     // The one and only Customer ArrayList addition in this Fn()
                                if (Customer.CustDict != null)
                                {
                                    if (!Customer.CustDict.ContainsKey(C.CustomerNumber))
                                    {
                                        Customer.CustDict.Add(C.CustomerNumber, C);
                                    }
                                }

                                Ccount++;
                                Customer.CustomersLinkedList.AddLast(C);
                            }

                            /*							// Handle multiple a/c's held by this customer
                             *                                                                                  if ( C . accountnums [ 1 ] != 0 )
                             *                                                                                  {
                             *                                                                                          BankAccount Bk = ( BankAccount ) SerializeData . ReadBankAccountFromDisk ( dir + "Bankobject" + C . accountnums [ 1 ] + ".bnk" );
                             *                                                                                          DataArray . ArrayAddBank ( Bk );// Add to bank ArrayList
                             *                                                                                          Bcount++;
                             *                                                                                          Bk . Dispose ( );
                             *                                                                                  }
                             *                                                                                  if ( C . accountnums [ 2 ] != 0 )
                             *                                                                                  {
                             *                                                                                          BankAccount Bk = ( BankAccount ) SerializeData . ReadBankAccountFromDisk ( dir + "Bankobject" + C . accountnums [ 2 ] + ".bnk" );
                             *                                                                                          DataArray . ArrayAddBank ( Bk );// Add to bank ArrayList
                             *                                                                                          Bcount++;
                             *                                                                                          Bk . Dispose ( );
                             *                                                                                  }
                             *                                                                                  if ( C . accountnums [ 3 ] != 0 )
                             *                                                                                  {
                             *                                                                                          BankAccount Bk = ( BankAccount ) SerializeData . ReadBankAccountFromDisk ( dir + "Bankobject" + C . accountnums [ 3 ] + ".bnk" );
                             *                                                                                          DataArray . ArrayAddBank ( Bk );// Add to bank ArrayList
                             *                                                                                          Bcount++;
                             *                                                                                          Bk . Dispose ( );
                             *                                                                                  }
                             */
//                            if (C != null)
//                             C.Dispose();
                        }
                        //                  if (B != null)
                        //                   B.Dispose();
                    }
                    count++;
                }
            }
            // save our Customer LinkedList to disk as binary and txt files
            Lists.SaveAllCustomerListData(Customer.CustomerFilePath + "CustSortedListData.cust");
            // sort the arrays in Ascending v0 - 9
            SortArray.SortBankArray(0);
            return(count);
        }
Exemplo n.º 4
0
        //****************************************************************************************************************************
        // this handles making a deposit call. creating the unique a/c #...
        // and creates a transaction record, and adds it to the linkedlist
        //**********************************************************************************************************//
        public static BankAccount CreateNewBankAccount(BankAccount bank, string CustNo, Int16 accounttype, decimal amount, decimal interest, string reason = "")
        //**********************************************************************************************************//
        {
            // create unique account number and set it in the account.
            bank.BankAccountNumber = GetBankAccountNumberSeed();// this post increments it's value internally
            bank.CustAccountNumber = Convert.ToInt32(CustNo);
            bank.Balance           = amount;
            bank.AccountType       = accounttype;
            bank.DateOpened        = DateTime.Today.Date;
            bank.InterestRate      = interest;
            //
            //This call increments the file numbering seed data
            bank.FileName = "BankObject" + bank.BankAccountNumber + ".bnk";
            // add full filename to the object
            bank.FullFileName = BankAccount.ReadBankFilePath() + bank.FileName;

            //This call increments the total banks seed data
            // Even though we do NOT need its content here.
            IncrementTotalBanks();

            // Ensure we save the file to disk for the Bank  object itself
            SerializeData.WriteBankAccountToDiskAndText(bank, bank.FullFileName);

            BankTransaction newbankaccount = new BankTransaction();

            newbankaccount.TransDate         = DateTime.Now;
            newbankaccount.AccountType       = bank.AccountType;
            newbankaccount.CustAccountNumber = bank.CustAccountNumber;
            newbankaccount.BankAccountNumber = bank.BankAccountNumber;
            newbankaccount.Transamount       = (decimal)bank.Balance;
            if (reason == "")
            {
                newbankaccount.Notes = "Opening Balance";
            }
            else
            {
                if (reason.Contains("Secondary Bank account  for Customer"))
                {
                    reason += bank.BankAccountNumber.ToString();
                }
                newbankaccount.Notes = reason;
            }
            newbankaccount.Status = bank.Status;
            // Add a transaction record
            BankTransaction.allBankTransactions.AddLast(newbankaccount);
            BankAccountsLinkedList.AddLast(bank);
            DataArray.ArrayAddBank(bank);
            // Update our new Dictionary system
            if (BankAccount.BankDict != null)
            {
                if (!BankAccount.BankDict.ContainsKey(bank.BankAccountNumber))
                {
                    BankAccount.BankDict.Add(bank.BankAccountNumber, bank);
                }
            }
            // This saves the bank LinkedList to both an object file and a Text file
            Lists.SaveAllBankAccountListData();

            //Add data ot our TWO hash tables
            // First the Customer hash tables
            try
            {
                if (CustomerBalanceHashTable.FindHashCustBalEntry(bank.CustAccountNumber.ToString()))
                {
                    CustomerBalanceHashTable.DeleteHashCustBalEntry(bank.CustAccountNumber.ToString());
                }
                CustomerBalanceHashTable.AddHashCustBalEntry(bank.CustAccountNumber.ToString(), bank.Balance);

                if (CustomerFileHashTable.CustFileNoHashTable.ContainsKey(bank.CustAccountNumber))
                {
                    CustomerFileHashTable.CustFileNoHashTable.Remove(bank.CustAccountNumber.ToString());
                }
                CustomerFileHashTable.CustFileNoHashTable.Add(bank.CustAccountNumber.ToString(), bank.FullFileName.ToString());
            }
            catch
            {
            }
            BankArrayChangedEvent?.Invoke(bank, "NEW BANKACCOUNT");
            return(bank);
        }
Exemplo n.º 5
0
        //======================================================================
        private void rewrite_Click(object sender, EventArgs e)
        //======================================================================
        {
            string output = "";

            if (notes.Text == "" || AccountNumber.Text == "" || AccountBalance.Text == "" || OpenDate.Text == "" || Interest.Text == "" || custno.Text == "")
            {
                MessageBox.Show("One or more data items are Empty - All fields must be completed before saving it ..." +
                                "\nRecommeded action is to use the DropDown list to reselect a valid Bank Account", "Data Validation ERROR");
                info.Text = "One or more data items are Empty - All fields must be completed before saving it ..."; return;
            }
            string stat;

            if (status.Text == "Active")
            {
                stat = "1";
            }
            else
            {
                stat = "0";
            }
            int type = AccountType.SelectedIndex + 1;

            // format is "Bank A/c #  + "," + Customer A/c # + "," + A/c Type + "," + Balance + "," + Date Opened (short) + "," + Date Closed (short) + "," + Interest + "," + Status (0/1)+ "\r\n"
            output  = AccountNumber.Text + "," + custno.Text + "," + type.ToString() + "," + AccountBalance.Text + ",";
            output += Convert.ToDateTime(OpenDate.Text).ToShortDateString() + "," + Convert.ToDateTime("01/01/0001").ToShortDateString() + "," + Interest.Text;
            output += "," + stat + "\r\n";
            string path = BankAccount.ReadBankFilePath();

            path += "Textfiles\\BankObject" + AccountNumber.Text + ".txt";
            if (File.Exists(path))
            {
                File.Delete(path);      // you gotta delete them first, else it appends the data constantly
            }
            File.AppendAllText(path, output);

            // update the bank object
            path  = BankAccount.ReadBankFilePath();
            path += "Bankobject" + AccountNumber.Text + ".bnk";

            // read the bank a/c in fresh from disk so it is clean
            BankAccount Bank = SerializeData.ReadBankAccountFromDisk(path);

            if (Bank == null)
            {
                MessageBox.Show("Bank Account Object file cannot be loaded (or saved)!", "Bank Object Error"); return;
            }
            Int32 bankno = Bank.BankAccountNumber;

            // update the Bank object
            Bank.AccountType = Convert.ToInt16(AccountType.SelectedIndex);
            Bank.AccountType++;// cos th reindex starts at ZERO !!
            Bank.Balance      = Convert.ToDecimal(AccountBalance.Text);
            Bank.InterestRate = Convert.ToDecimal(Interest.Text);
            string banknostring = Bank.BankAccountNumber.ToString();

            //Update the version in Bank Array
            int index = DataArray.ArrayFindBank(Bank);

            DataArray.BankNo[index] = Bank;

            // Update the version in our Bank LinkedList
            foreach (var B in BankAccount.BankAccountsLinkedList)
            {
                if (B.BankAccountNumber == bankno)
                {   // got it, rpelace with our new one
                    BankAccount.BankAccountsLinkedList.Remove(B);
                    BankAccount.BankAccountsLinkedList.AddLast(Bank);
                    break;
                }
            }
            // This saves the bank LinkedList to both an object file and a Text file
            Lists.SaveAllBankAccountListData();
            // write theBank object to disk
            SerializeData.WriteBankAccountToDiskAndText(Bank, path);
            // Add a bank Transaction
            BankTransaction newbankaccount = new BankTransaction(Bank.DateOpened, Bank.AccountType, Bank.CustAccountNumber,
                                                                 Bank.BankAccountNumber, Bank.Balance, "Bank details edited from Textfile input", Bank.Status);

            BankTransaction.allBankTransactions.AddLast(newbankaccount);
            // that's it ***ALL***all Bank Data structures have been updated
            info.Text = "Bank Account data has been fully updated throughout System";
        }
Exemplo n.º 6
0
        public static int RebuildBankListsFromText( )
        {
            int    count = 0;
            string fi    = BankAccount.ReadBankFilePath( ) + "Textfiles\\BankAccountListData.txt";

            if (File.Exists(fi))
            {
                string input = File.ReadAllText(fi);          // you gotta delete them first, else it appends the data constantly
                char[] ch1   = { '\r' };
                char[] ch2   = { ',' };
                //				char [ ] ch3 = { '~' };
                string[] record = input.Split(ch1);
                string[] BAccts;

                DataArray.ArrayClearBank( );
                BankAccount.BankAccountsLinkedList.Clear( );
                // record now has an array of strings that were split on \t
                // this means we should have at least one, possibly multiple  B.Accs  in the last element
                // iterate through and split these out of record into string[] Item2
                for (int i = 0; i < record.Length; i++)
                {
                    string str = record[i];
                    //This should give us x strings,, the first one can be ignored
                    //, the rest will be bank account numbers cos the format is  "xxxxxx,xxxx,yyyy,~4455554544~65645
                    // and we are after the data immediately past the first ~
                    string[] Item2 = str.Split(ch2);
                    // check.  The plit always gives us ~ONE element, even though it is empty
                    if (Item2.Length == 1 && Item2[0].Length == 0)
                    {
                        break;  // Were all done here
                    }
                    BAccts = Item2[7].Split('~');
                    // go get em (one or more B Accts in a BAccts[] string[]
                    if (BAccts.Length > 1)
                    {   // got one or more - do something with them ?
                    }
                    //Baacts MAY contain a leading EMPTY string, so beware
                    // by here , we have an array of strings of Bank accounts owned by this customer. ?
                    for (int x = 0; x < record.Length; x++)
                    {
                        // get a string from string[] array Item1[]
                        BankAccount B = new BankAccount( );
                        if (B != null)
                        {
                            B.AccountType       = Convert.ToInt16(Item2[x]);
                            B.CustAccountNumber = Convert.ToInt32(Item2[x + 1]);
                            B.BankAccountNumber = Convert.ToInt32(Item2[x + 2]);
                            B.Balance           = Convert.ToDecimal(Item2[x + 3]);
                            B.DateClosed        = Convert.ToDateTime(Item2[x + 4]);
                            B.InterestRate      = Convert.ToDecimal(Item2[x + 6]);
                            // We dont seem to save this ?????
                            B.Status = 1;
                            BankAccount.BankAccountsLinkedList.AddLast(B);     // Add this one to our linked list of customers.
                            DataArray.ArrayAddBank(B);
                            if (BankAccount.BankDict != null)
                            {
                                if (!BankAccount.BankDict.ContainsKey(B.BankAccountNumber))
                                {
                                    BankAccount.BankDict.Add(B.BankAccountNumber, B);
                                }
                            }
                            SerializeData.WriteBankAccountToDiskAndText(B, fi);
                            count++;
                            break;
                        }
                    }
                    // save linked list to disk in text format
                    Lists.SaveAllBankAccountListData( );
                }
            }
            return(count);
        }