MCA Project Reprot

A
PROJECT REPORT
ON
Bank Accounting Software

Submitted in partial fulfillment of
Master of Computer Application
Of the Rajasthan Technical University,
Kota.
Session: 2009-2010
Guided by:
Mr.SURENDRA CHODHARY
(LECTURER)
Deptt. Of MCA
Submitted By:
RACHNA
PRAGYA SHARMA
KIRTI SHARMA
SRI BALAJI COLLEGE OF ENG. & TECH. , Jaipur

Synopsis
BANK ACCOUNTING SOFTWARE
Banks being the treasure for a common man in todays world. It is the
store house of the earnings & savings of the people. Starting from a
common man to very large firms. All hold their bank account which
allow then save & easy money transaction.
With the increasing globalization wide range of changes are coming
in system. Now a days bank provides different type of facilities to
their account holder like transaction and various types of accounting
services. These accounts are available for individual or a firm who
deals with large money transaction during a single day. In our
project, Bank Accounting Software we deal with transactions of
accounts, various modifications of accounts etc. The coding of
software is in C++ language. The database is handled through Dat
files.
Guided By
Mr.SURENDRA CHODHARY
(Lecturer)
Submitted By
RACHNA
PRAGYA SHARMA
KIRTI SHARMA
TITLE
OF
PROJECT
BANK
ACCOUNTING
MANAGEMENT
SYSTEM
MEANING
OF
PROJECT
Before starting the project we should fully know about the meaning of
project,
There are seven letters in the word PROJECT each character has its own
technical meaning.
Planning
This deal with the idea at thinking and which are required for the
project.
R esource
The money problem will be solved and resources from which
collected.
O perating
The procedure from which the getting job is prepared in a systematic
way is known as operation.
Joint effort
This is directly proper to a operation output is made of several
person working sincerely is known as JOINT EFFORT.
Engineering
A well-educated engineer can do this work in a better way to find

out better result. Hence the project is as engineering function.
Co-operation
To make the project successfully, it is necessary for its success
and completion of project.
Technique
It must as it gives a better shape. It is not possible to complete the
project without technique.
The project is a system that gives the systematic way of planning and
working.
PROBLEM DEFINITION
Goals that are successfully achieved:
This software stores data related to the offices of the agency,

Customer seats, Routes, buses and employees in a way that allows
on accessing existing information and current position. This also
allows submitting new entries and modifying entries in the related
database by the user.
Second Goal is to develop software that helps in the analysis of up

to date information about booking of seats and per seat cost, per
bus expenses.
Third goal is used to this package to analysis the data and interpret
result
in meaningful manner.
Demerits of Existing Systems

In the current working system the user faces so many problems. Some of
them are given below:1) It takes to much time to get details of any of the customer, available
Routes information , Bus information .
2) The use of man power in the existing system is so high because
maintaining the details about all the present stock and its item-wise
informations and many other processes.
3) Need a lot of paper work (registers).
4) Need a much skilled persons to take care all the activities.
5) Calculation mistake are another problem for the system and have
drawback of accuracy of result obtained.
DEPARTMENT OF MASTER OF COMPUTER APPLICATION
SRI BALAJI COLLEGE OF ENG. & TECH.

RAJASTHAN TECHNICAL UNIVERSITY
CERTIFICATE
This is to certify that the project on Bank Accounting Software submitted
by RACHNA,PRAGYA SHARMA & KIRTI SHARMA
students of Second year (IV SEM.) of Master of Computer
Application under my supervision is students own work and
has not been submitted elsewhere for the award of any degree.
The project report and the presentation are based on the
knowledge of them in this field.
MR. SURENDRA CHODHARY

Head of Department
Deptt. Of M.C.A.
ACKNOWLEDGEMENT
We are greatly thankful to our project guide Mr.

,
Lecturer, MCA, who inspired us to present our project on Bank
Accounting Software. He helped and encouraged us in every
possible way the knowledge required during the preparation of the
project. This would definitely help us in our future ventures.
We would like to express our deep sense of gratitude and MR.
Surendra Chodhary, HOD, Department of MCA for giving us the
opportunity to submit our project.
We are greatly indebted to all of the helping factors concerned with
the successful completion of this project.
Guided by:
Submitted By:
Mr. SURENDRA CHOUDHARY
RACHNA
(LECTURER)
Deptt. Of MCA
PRAGYA SHARMA
KIRTI SHARMA
ABSTRACT
common man to very large firms. All hold their bank accounts which
allow them to save money & ease money transaction.
Now a days bank provides different type of facilities to their account
holder like transactions and various types of accounting services. One
of the types of accounting service is current bank account.
Our project, Bank Accounting Software is useful for the operator who
is a bank employee. Customer provides his information to the
operator and then operator puts this information as customer entries
to the software. Using this software, operator maintains a database of
each customers account and also the list of accounts of various
customers. With the help of this software, operator can manipulates
customers account and provides interest to the customers on
monthly basis. Operator also makes transactions to the customers
account with ease of handling.
In future, we will try to make this software much capable to be
implemented on the distributed system using SQL Server
Connectivity due to which many operators can access the database at
a time by the help of generated SQL Queries.
We can also further extend the implementation of this software by
including the customers so that they can access the software to check
their accounts. For this purpose, we need some type of mechanism or
hardware that provides access of the software only to the authorized
customers.
CONTENTS
Chapter...Chap
ter Name.
1....Introduction
2...Objective of the Project
33.1 Tools / Environment Used
3.2 Hardware Requirement
4Complete Analysis & Design Document
5..5.1 Entity Relationships Diagram
5.2 Data Flow Diagram
6..Program Structure
7.Coding
8...8.1 Main Menu Screen
8.2 Input Screen
8.3 Transaction Screen
8.4 Edit Menu Screen
8.5 Modify Account Screen
8.6 Close Account Screen
8.7 Displays /Output Screen

8.8 Help Menu Screen
9...Limitations of the Project
List of Figures
Figure.................................
Name of the Figure.
1..Main Menu and Sub Menus
2.Entity Relationship Diagram
3.Level 0 Data Flow Diagram
7.Main Menu Screen
8.Open New Account Screen
9......Transaction Screen
10.Edit Menu Screen
11Modify Account Screen
12...Close Account Screen
13...Account Table Screen

14.Customer Table Screen
15....Help Menu Screen
List of Tables
Table No.
Table Name.
1.Account Table
2......Customer Table
# Bibliography and References

# Conclusion
Bibliography and References
Software Engineering....Roger
S. Pressman
Programming with C++...E.
Balagurusamy
Let Us C++..Yashavant P.
Kanetkar
Conclusion
The overall conclusion of our project Bank

Accounting Software is that this software
serves the whole purpose of the bank operator.
This software is easily manageable as the
database of the customers account and the
database of the different customers are easily
handled. Also, the process of making
transactions and modifications in the accounts of
the customers is simple.
In future, we will try to make this software
much capable to be implemented on the
distributed
system
using
SQL
Server
Connectivity due to which many operators can
access the database at a time by the help of

generated SQL Queries.
We can also further extend the implementation
of this software by including the customers so
that they can access the software to check their
accounts. For this purpose, we need some type
of mechanism or hardware that provides access
of the software only to the authorized
customers.
SYSTEM ANALYSIS
The Process of system creation begins long before
the first line of the program code for the new system
is written, when the exiting system, whether manual
or automated, is systematically evaluated, analyzed,
planned, properly described and documented,
criticized and appropriate modifications are
suggested and finding thus obtained are then
synthesized as the new system in the designing phase.
To design any system the analysis and study of vital
importance. If you dont analyze it is highly likely
that youll build a very elegant software solution that
solves the wrong problem. The result is wasted the
and money, personal frustration and unhappy

customers. The analysis phase includes the study of
data and gathering of information. During this period
the analyst compares objectives, goals, functions,
priorities and time period. The requirement are
refined and analyzed to assess their clarity,
completeness and consistency.
An engineer involved in the project see manually
work for testing process and collect data on the basis
of data and quantity the report is time consuming and
also error prone as manual computations are involved
and desired result is achieved result in lesser time.
This will increase the overall system efficiency.
Preliminary Investigation
The first step in the system development life cycle is
the preliminary investigation to determine the
feasibility of the system. The purpose of preliminary
investigation is to evaluate project requests. It is not a
design study nor does it include the collection of
information that helps to evaluate project requests. It
is the collecting of information that helps to evaluate
the merits of the project request and make an
informed judgment about the feasibility of the
proposed project.
In order to conduct investigation for this project the

following primary methods were used:
Reviewing existing document : In order to know how
the job to be accomplish is currently carried out who
are the persons directly associated with system the
existing documents, which were prepared manually
by the engineers, were examined and the written and
the written operating procedures were studied. The
procedures and the persons directly associated with
the system the existing documents, which were
examined and the written operating procedures were
studied . The procedures clearly define various
important step involved in the system.
FEASIBILITY STUDY
Once the problem has been identified, elements of
solution have been proposed , different approaches
have been negotiated and a preliminary set of
requirement have been specified, it is reasonable to
ask Is the project feasible? Not everything
imaginable is feasible, not even in software. On the
contrary, software feasibility has four solid
dimensions:
Technology: Is a project technically feasible? Can
defects be reduced to a level matching the
applications needs ? Finance: It is financially
feasible? Can development be completed at a cost the
software organization, its client, or the market can

afford?
Time: will the projects time-to-market beat the
competition? Resources: Does the organization have
the resources needed to succeed?
The following three important tests of Feasibility
were studied:
Operational Feasibility
Proposed projects are beneficial only if they can be
turned into information systems that will meet the
operating requirements of the organization. This test
of Feasibility asks whether the system will work
when it is developed and installed. This project was
found to be feasible operationally for the following
reasons:
There was sufficient support from the users.
Users were ready to accept a change that would
bring about a more operational and useful
system.
The users were involved in the planning and
development of the project.
Technical Feasibility
There are a number of technical issues which were
generally raised during feasibility stage of
investigation:
Does the necessary technology exist to do
what is suggested?
Does the proposed equipment have the

technical capacity to hold the data required
for using the new system?
Can the system be upgraded if developed?
Are there technical guarantees of accuracy,
reliability, ease of access and data security
Keeping the above mentioned points in mind the
proposed system was analyzed and was found to
technically feasible.
SOFTWARE ENGINEERING PARADIGM

APPLIED
Also called the classic life cycle of the waterfall
model, the linear sequential model suggests a
systematic sequential approach to software
development that begins at the system level and
progresses through analysis, design, coding, testing
and support.
For the developing this software the above mentioned
software-engineering paradigm was applied.
The Linear sequential paradigm encompasses the
following activities.
Systems/information engineering & Modeling:
Because software is always part of the large system,
work begins by establishing requirements for all

systems elements and than allocating some subset of
these requirements to software. This system view is
essential when software must interact with other
elements such as hardware, people and
databases.system engineering and analysis
encompass requirements gathering at the system level
with small amount of to level design and analysis.
Software Requirements Analysis: The
requirements gathering process is intensified and
focused specially on software. To understand the
nature of the program to be built, the software
engineer must understand the information domain for
the software as well as required function, behavior,
performance and interface. Requirements for both the
systems and the software are documented and
reviewed with the customer.
Design: Software design is actually a multi step
process that focuses on four distinct attributes of a
program: data structure, software architecture,
interface representation, and procedural detail. The
design process translates requirements into a
representation of the software that can be assessed for
quality before coding begins.
Code Generation: the design must be translated into
a machine-readable form. The code generation step
performs this tasks. If design is performed in a
detailed manner code generation can be accomplished
mechanistically.
Testing: once code has been generated , programs

testing begins.the testing focuses on the logical
internals of the software ensuring that all statement
have been tested and on the function ; that is
conducting test to uncover errors and ensure that
defined input will produce actual results that agree
with required results.
Implementation: After testing the system was
successfully implemented.
Documentation: the software passes all software
testing then it delivered to client with its
documentation or user manual that are generated after
each phase of SDLC.
SOFTWARE REQURIEMENTS
SPECIFICATION
1.
Introduction and purpose:

Bus Reservation Management System is
software
developed
for
passengers
Reservations. it is designed for testing and on
basis for process purpose. It gives us view that
which bus seat is booked and which one is
cancelled.
The purpose of this software is to eliminate the

manual labor the automation of the above also
reduces the chances of errors u\in the
computations involved.
HARDWARE REQUIREMENT
SPECIFICATION
1. Processor: P4 & Above
2. 500 MHz & above
3. 128 MB RAM
4. Laser/ Deskjet Printer
SYSTEM DESIGN
Design is a meaningful engineering
representation of something that is to built.
It can traced to a customers requirements
and at the same time assessed
For quality against a set of predefined
criteria for good design. In the software
engineering context design focuses on four
major areas of concern: data, architecture,
interfaces and components.
Design begins with the requirements model.
This model is to transformed into four levels
of design detail: the data structure, the
system
architecture,
the
interface
representation and the components level

detail. during each design activity, the basic
concepts and principles are applied that lead
to high quality.
Data Design
Data design creates a model of data or
information that is to be represented at a
high level of abstraction. That data model is
then refined into [progressively more
implementation-specific representation that
can be processed by the computer-based
system. The data objects defined during
software requirements analysis are modeled
using E-R Diagrams and the data Dictionary.
The data design activity translates these
elements of the requirement model into data
structures at the software component level.
Scope of this project Bus Reservation

Management is to provide a systematic
management of the policies..
It helps the Travel Owner to maintain their
records quickly and accurately. it also
provides quick retrieval of records . Makes
easy to get daily summary of figures in less

time frame. Supported with more analytical
reports with graphical presentation. The
application will completely eliminate all
manual operations.
1. Introduction
common man to very large firms. All hold their bank accounts which
allow them to save money & ease money transaction.
With the increasing globalization wide range of changes are coming
in system. Now a days bank provides different type of facilities to
their account holder like transactions and various types of accounting
services. One of the types of accounting service is current bank
account.
These accounts are available for individual or firms who deal with
large money transaction during a single day without paying any extra
charges as not in the case of saving account provided.
All the daily transactions are properly maintained by the
system.
Customers can modify their accounts.

Customer may close accounts.
Our project, Bank Accounting Software is useful for the operator who
is a bank employee. Customer provides his information to the
operator and then operator puts this information as customer entries
to the software. Using this software, operator maintains a database
for each customers account and also the list of accounts of various
customers. With the help of this software operator can manipulates
customers account and provides interest to the customers on
monthly basis. Operator also makes transactions of the customers
account with ease of handling.
2. Objective of the project

The main objective of our project is to seek out the difficulties faced
by the bank operator when he deals customers account manually.
Using our Bank Accounting Software, bank operator can do the
following functions:
1. Operator can open a new account of the customer.
2. Operator can edit the accounts of the customers.
3. Operator can make transactions like deposit or withdraw using
DD/Cheque.
4. Using this software, operator can maintain a database for the
customers account and also the list of accounts of various
customers.
5. Our software can automatically calculate the interest on
monthly basis.
6. Our software can automatically generate Account No. while
opening new account.
7. Using this software, operator can save his time because in banks
the main time is wasted in paper handling.
8. Using this software, operator does not require paper documents
to fill all the entries of the customers during transactions and
only the important documents has to store like, declaration
papers.
9. Using this software, operator can accurately compute the
balances for each customers account.
10.Using this software, operators get reliability and efficiency.
3.1 Tools / Environment used:

Platform Used: Windows 9X Series
Assortment of appropriate operating system for any project is very
important. Basically it depends upon nature of project and its system
requirements. Windows provide a multitasking environment,
enabling user to run various application at a time. Windows offer
many advantages to both user and programmer.
Language Used: C++
In this project, we use C++ language since it is a superset of C. That
means it possesses all the features and all the functionalities of C. It
offers versatility, power and portability. This project does not adapt
dogmatic and purist approach to OOP. Rather it masterfully mixes C+
+ technique with already proven C graphics routines.
3.2 Hardware Requirement:

Processor (CPU)
Primary Memory (RAM)
Hard Disk Drive
Display Size
Key Board Keys
Pentium 1 (100 MHz)

64 MB
20 GB
14 Monitor
Total 104 keys with 12 functions
4. Complete Analysis & Design Document

The following diagram depicts the overall design of the software
system:
Figure 1
In our project, Bank Accounting Software, customer is an input entity

which provides his information to the Bank operator which enters
this information as customers entries to the software.
The root of this project lies in the creation of menus. Main Menu is
the base of this software from where the operator can branch into
several sub programs or modules or sub menus. This will make it
easy for the operator to choose a desired option by using keyboard
keys. The sub menus are as follows:
Open New Account

Transaction
Edit Account
Display
The option Open New Account generates the Account No. For
opening new account, the operator has to put customer name,
customer address and the initial deposit which should not be less
than Rs.500/-.
The option Edit Account also can be done into two ways:
1. Operator can modify the account by modifying customer name
or customer address.
2. Operator can also close any account of the customer.
The option Display is useful for displaying two tables to the operator
which are as follows:
Table 1: Account Table
Table 2: Customer Table
5.1 Entity Relationship Diagram (ERD)

The ERD depicts the relation between data objects. The ERD is the
notation that is used to conduct the data modeling activity. The
attributes of each data objects noted in the ERD can be described
using a data object description.
SYMBOLS
MEANING
The ERD of our project is as follows
Figure 2
The ERD of our project consists of two main entities:
1. Customer
2. Account
Customer is an input entity which has the attributes such as Account
No., Cust_Name and Address. Customer entity has a relationship
with the Account entity which has cardinality one to many. Account
entity also consists of Account No., Cust_Name, Particular,
Transaction Type, Interest and Balance. The attribute Account No. in
both the entities is unique for each customer.
5.2 Data Flow Diagram (DFD)

Data flow diagram serves two purposes:
1. To provide an indication of how the data is transformed as
they move through the system.
2. To depict functions that is used during the analysis of the data
flow. The DFD provides additional information that serves as a
basis for the modeling of the functions. A description of each
function presented in the DFD is contained in a process

specification.
The DFD are in levels. There are three levels of DFD which depicts
the whole process of our project.
0-level DFD
1-level DFD
2-level DFD
Level-0 DFD is the DFD in which the whole process is of a system,
depicted by the help of only one bubble. This is also called
fundamental state of DFD.
Level-1 DFD is DFD in which the whole system is divided into about
7 or 8 bubbles. These bubbles are the part of main bubble which
shows the whole process in level-0 DFD.
Level-2 DFD is DFD in which the processes of the Level-1 are divided
into many parts or bubbles.
The DFD of our project is as follows:
Figure 3
Figure 4
Level 2 Data Flow Diagram for the process Transaction

Figure 5
Program Structure:
This program structure consists of four classes:
Class Shape
Class Control
Class Initial
Class Account
Class Shape:
This class contains the following member functions use to draw box
etc. All these functions are public.
1. void line_hor (int, int, int, char);
This member function is used to draw horizontal line.
2. void line_ver (int, int, int, char);
This member function is used to draw vertical line.
3. void box (int, int, int, char);
This function is used to draw rectangular boxes using function
line_hor and line_ver.
Class Control:
This class is used to control all the functions in the menu.
It consists of following functions:
1. void main_menu (void)
This is a public function; this function is used to draw the main menu
page consisting of seven options which are provided by accounting
software as follows:
See Account
List of Accounts
Transactions
Open New Account
Edit Account
Help
Quit
This function also uses other functions:
void selected(int);
void toggle(int,int);
These sub functions are used to handle the arrow keys to select the
options provided by accounting software.
Main_menu function is also used further to define graphical support
for the software.
2. void edit_menu (void)
This is a private function; this function is applied by selecting the
option Edit Account of main_menu function. It is used to design the
Edit Menu consisting of three options:
Modify Account
Close Account
Quit
3. void help (void)
This is a public function; this function is applied by selecting the
option Help of main_menu function. It is used to display the Help
Menu.
Class Initial:
This class contains the functions related to the initial deposit. It
consists of following member functions:
Public Functions:
1. void add_to_file (int, char t_name [30], char t_address [60], float);
2. void display_list (void);
3. void delete_account (int);
4. void update_balance (int, float);
5. void modify (void);
6. int last_accno (void);
7. int found_account (int);
8. char * return_name (int);
9. char * return_address (int);
10. float give_balance (int);
11. int recordno (int);
12. void display (int);
Private Functions:
1. void modify_account (int, char t_name [30], char t_address [60]);
2. void box_for_list (void);
Explanation of Functions:
1. void add_to_file (int, char t_name [30], char t_address [60], float);
This public function is used to add the given data into the file
Initial.dat.
2. void display_list (void);
This public function is used to display the list of accounts in the file
Initial.dat.
This public function is used to delete the record for the given account
no. from the file initial.dat.
4. void update_balance (int, float);
This public function is used to update balance for the given account
no. from the file initial.dat.
5. void modify (void);
This public function is used to give the data to modify the record in
the file initial.dat. This function is used in correspondence with the
function modify_account and applied whenever the option
edit_account of main_menu function of control class is selected. This
function provides name, address to the function modify_account &
modify_account function modifies the record for the given data in the
file initial.dat.
6. int last_accno (void);
This is the public function is used to return the last account no. in the
file initial.dat.
7. int found_account (int);

This public function is used to check the validity either account no. is
present in the file initial.dat or not. This function return 1 if the given
account no. is found in the file initial.dat & it is used in
correspondence with display (int) function which provides display of
the account for the given account no.
8. char * return_name (int);
This public function return the name for the given account no. in the
file initial.dat and it is used in correspondence with the function
display (int).
9. char * return_address (int);

This public function returns the address for given account no. in the
file initial.dat & it is used in correspondence with the function
display (int).
Class Account:
This class contains the functions related to transaction. It consists of
following functions:
Public Functions:
1. void close_account (void)
2. void new_account (void)
3. void display_account (void)
4. void transaction (void)
5. void clear (int, int)
Private Functions:
1. void add_to_file(int,int,int,int,char,char t_type[10],float, float,flaot);
3. int no_of_days (int, int, int, int, int, int);

4. float calculate_interest (int, float);
6. void box_for_display (int);
Explanation of Functions:
1. void close_account (void)
This public function is used to close the account (delete account). This
function is applied whenever the option edit_account of main_menu
function of control class is selected. Further this function requires the
account no. which is provided by the operator for closing the account.
Then, this function displays the name of customer, his address and
last balance and also displays the current date using structure date.
Finally, operator can close the account by choosing the option yes or
no.
2. void new_account (void)

This public function accepts the data to add records in the file
banking.dat. This function is applied whenever the option open new
account of main_menu function of control class is selected. It
provides the account no. of its own and the operator enters the name
of customer, his address & the initial deposit. This function must
satisfy the following constraints:
1. Name of the customer should not be greater than 25 characters and
should not be blank.
2. Address of the customer should not be greater than 25 characters
and should not be blank.
3. Initial deposit should not be less than Rs.500/-.
Finally, this function provides the current date using structure date;
this current date is used as the date of the initial deposit & displayed
to the operator.
3. void display_account (void)
This public function is used to display the record for the option
provided by box_for_display function from the file banking.dat.
4. void transaction (void)

This public function is used to make transaction like deposit or
withdraw. This function is applied whenever the option transaction of
the main_menu function of control class is selected. Initially, this
function requires the account no. which is provided by the operator
to make transactions. Then, it displays name of customer, his address,
his last balance & also the current date using the structure date.
Further, it provides the options like deposit or withdraw for the
transaction & also the option like DD or cheque as amount type by
which transaction takes place.
This public function is used to clear the given row and column.
6. void add_to_file(int,int,int,int,char,char t_type[10],float, float,flaot);
This private function is used to add the given data into the file
banking.dat.
This private function is used to delete the record for the given
account no. from the file banking.dat.
8. int no_of_days (int, int, int, int, int, int);
This private function is used to calculate the difference between two
dates & then return it. Further, this difference is used as to calculate
the interest.
9. float calculate_interest (int, float);
This private function is used in correspondence with no_of_days
function and use the difference of two dates. The purpose of this
function is to calculate the interest on monthly basis. The rate of

interest is 2%.
10. void box_for_display (int);

This function is private and used to draw the box for displaying the
records from the file banking.dat. This function is used to display
various options like date of initial deposit or transactions (deposit or
withdraw), particular which shows either your deposit is Initial
Deposit or by DD or cheque for transactions, Deposit amount,
Withdraw amount, Interest, Balance. This function also displays the
name of customer, his address & also the current date using structure
date.
8.1 MAIN MENU SCREEN
Figure 7: Main Menu Screen
8.2 INPUT SCREEN
Figure 8: Open New Account Screen

On selecting the Open New Account option on Main Menu Screen,
operator gets the Input screen known as Open New Account Screen.
This screen generates the Account No. automatically. The operator
only enters the name of the customer, his address and the initial
deposit to open the customers account.
8.3 TRANSACTION SCREEN
Figure 9: Transaction Screen

On selecting the Transaction option on Main Menu screen, operator
gets the Transaction Screen. This screen displays the account no.,
customer name, his address and the last balance in his account. The
operator has to enter the amount for transaction i.e. Deposit or

Withdraw by DD or Cheque.
8.4 EDIT MENU SCREEN
Figure 10: Edit Menu Screen

On selecting the Edit Account option on Main Menu Screen, operator
gets the Edit Menu Screen. This screen consists of two options:
1. Modify Account
2. Close Account
8.5 MODIFY ACCOUNT SCREEN
Figure 11: Modify Account Screen

On selecting the Modify Account option on Edit Menu Screen,
operator gets the Modify Account Screen. This screen displays the
account no., customer name, his address and the last balance in his
account. The operator can modify either name of the customer or

address of the customer.
8.6 CLOSE ACCOUNT SCREEN
Figure 12: Close Account Screen

On selecting the Close Account option on Edit Menu Screen, operator
gets the Close Account Screen. This screen displays the account no.,
customer name, his address and the last balance in his account. The
operator can close or delete his account.
8.7 DISPLAY/OUTPUT SCREENS

8.7.1 ACCOUNT TABLE SCREEN
Figure 13: Account Table Screen

8.7.2 CUSTOMER TABLE SCREEN
Figure 14: Customer Table Screen
8.8 HELP MENU SCREEN
Figure 15: Help Menu Screen

On selecting the Help option on Main Menu Screen, operator gets the
Help Menu Screen. This screen displays the information about the
options present on the Main Menu Screen.
LIMITATIONS OF THE PROJECT
Although, our project Bank Accounting Software provides various

features like opening of the new accounts, transactions (Deposit /
Withdraw) into the accounts, modifications into the accounts and so
on. But there are some limitations of this software:
1. This software does not provide any validity check to the
operators of the bank for security purposes.
2. This software does not provide any centralized database for the
accounts of the customers because the implementation of this
software is limited to a single system rather than on the
distributed system using Client/Server approach.
implemented on the distributed system using SQL Server
customers.
LIMITATIONS OF THE PROJECT

Although, our project Travel agency Accounting Software provides
various features like opening of the new accounts, transactions
(Deposit / Withdraw) into the accounts, modifications into the

accounts and so on. But there are some limitations of this software:
3. This software does not provide any validity check to the
operators of the travel agency for security purposes.
4. This software does not provide any centralized database for the
accounts of the customers because the implementation of this
software is limited to a single system rather than on the
distributed system using Client/Server approach.
implemented on the distributed system using MS-Access
customers.
COADING:
#include <graphics.h>
#include <dos.h>
#include <iostream.h>
#include <fstream.h>
#include <process.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <dos.h>
void gra1();
void gra2();
//Program segment to display some graphic
void box(int,int);
//**********************************************************
// THIS CLASS CONTAINS FUNCTIONS RELATED TO
DRAW BOX ETC.
//**********************************************************
class shape
{
public :
functions
void line_hor(int, int, int, char) ;
void line_ver(int, int, int, char) ;
void box(int,int,int,int,char) ;
};
//Public
member
//**********************************************************
// THIS CLASS CONTROL ALL THE FUNCTIONS IN THE
MENU
//**********************************************************
class control
{
public :
void main_menu(void) ;
functions
void help(void) ;
private :
void edit_menu(void) ;
};
//Public member
//Private member functions
//**********************************************************
// THIS CLASS CONTAINS FUNCTIONS RELATED TO INITIAL
DEPOSIT
//**********************************************************
class initial
{
public :
void add_to_file(int, char t_name[30], char t_address[60],
float) ;
void display_list(void) ;
void delete_account(int) ;
void update_balance(int, float) ;
void modify(void) ;
int last_accno(void) ;
int found_account(int) ;
char *return_name(int) ;
//So that the private
members of class
char *return_address(int) ;
//can be used in required
segments.
float give_balance(int) ;
int recordno(int) ;
void display(int) ;
private :
void
modify_account(int, char t_name[30], char
t_address[60]) ;
void box_for_list(void) ;
int accno ;
//Private member elements
char name[30], address[60] ;
float balance ;
};
//**********************************************************
// THIS CLASS CONTAINS FUNCTIONS RELATED TO
TRANSACTIONS
//**********************************************************
class account
{
public :
void new_account(void) ;
void close_account(void) ;
void display_account(void) ;
void transaction(void) ;
void clear(int,int) ;
private :
void add_to_file(int, int, int, int, char, char t_type[10],
float, float, float) ;
void delete_account(int) ;
int no_of_days(int, int, int, int, int, int) ;
float calculate_interest(int, float) ;
void display(int) ;
void box_for_display(int) ;
};
int accno ;
char type[10] ;
// Cheque or Cash
int dd, mm, yy ; // Date
char tran ; // Deposit or Withdraw
float interest, amount, balance ;
//**********************************************************
// CLASS SHAPE :: FUNCTION TO DRAW HORIZONTAL LINE

//**********************************************************
void shape :: line_hor(int column1, int column2, int row, char c)
{
for ( column1; column1<=column2; column1++ )
{
gotoxy(column1,row) ;
cout <<c ;
}
}
//**********************************************************
// CLASS SHAPE :: FUNCTION TO DRAW VERTICAL LINE
//**********************************************************
void shape :: line_ver(int row1, int row2, int column, char c)
{
for ( row1; row1<=row2; row1++ )

{
gotoxy(column,row1) ;
cout <<c ;
}
//**********************************************************
// CLASS SHAPE :: FUNCTION TO DRAW BOX LINE
//**********************************************************
void shape :: box(int column1, int row1, int column2, int row2, char c)
{
char ch=218 ;
char c1, c2, c3, c4 ;
char l1=196, l2=179 ;
if (c == ch)
{
c1=218 ;
c2=191 ;
c3=192 ;
c4=217 ;
l1 = 196 ;
l2 = 179 ;
}
else
{
c1=c ;
c2=c ;
c3=c ;
c4=c ;
l1 = c ;
l2 = c ;
}
gotoxy(column1,row1) ;
cout <<c1 ;
cout <<c2 ;
cout <<c3 ;
cout <<c4 ;
column1++ ;
column2-- ;
line_hor(column1,column2,row1,l1) ;
line_hor(column1,column2,row2,l1) ;
column1-- ;
column2++ ;
row1++ ;
row2-- ;
line_ver(row1,row2,column1,l2) ;
line_ver(row1,row2,column2,l2) ;
}
//**********************************************************************
// CLASS CONTROL :: FUNCTION TO DISPLAY MAIN MENU
AND CALL
OTHER FUNCTIONS
//**********************************************************************
void control :: main_menu(void)

{
void selected(int);
void toggle(int,int);
char m1[]="
SEE ACCOUNT
",m2[]=" LIST OF
ACCOUNTS",m3[]="
TRANSACTIONS
", m4[]=" OPEN NEW
ACCOUNT",m5[]="EDIT ACCOUNT",m6[]=" HELP
", m7[]="
QUIT
";
static int counter=0;
while(1)
{
int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"..\\bgi");
counter++;
setfillstyle(1,7);
floodfill(320,240,1);
settextjustify(1,1);
setcolor(8);
settextstyle(7,0,0);
setusercharsize(27,10,5,3);
if (counter==1)
{
outtextxy(320,35,"B
"); delay(200);
outtextxy(320,35," A
"); delay(200);
outtextxy(320,35," N
"); delay(200);
}
else
{
outtextxy(320,35,"
K
"); delay(200);
outtextxy(320,35,"
I "); delay(200);
outtextxy(320,35,"
N "); delay(200);
outtextxy(320,35,"
G");
for(int i=0,j=640;i<610;i++,j--)
{
sound(2*i);
setcolor(8);
line(i,15,i-570,15);
line(j,65,j+570,65); delay(5);
putpixel(i-570,15,7);
putpixel(j+570,65,7);
}
nosound();
setusercharsize(27,12,5,3);
outtextxy(320,35,"B A N K I N G");
setcolor(8);
line(610,15,40,15);
line(600,65,30,65);
}
outtextxy(90,270,"O P T I O N S");
outtextxy(550,270,"O P T I O N S");
char ch;
do
{
temp=choice;
ch=getch();
switch (ch)
{
case 72:
case 75: choice=((--choice+7)%7);

toggle(choice,temp);
continue;
case 77:
case 80: choice=(++choice%7);
continue;
case 73: choice=(choice+12)%7;
break;
case 81: choice=(choice+2)%7;
break;
case 71:
case 49: choice=1;
break;
case 50: choice=2;
break;
case 51: choice=3;
break;
case 52: choice=4;
break;
case 53: choice=5;
break;
case 54: choice=6;
break;
case 79:
case 55: choice=0;
break;
case 27: choice=0;
case 13: selected(choice);
delay(500);
}
}while (ch!=13&&ch!=27);
for(int i=320;i>0;i--)
{
if((counter==1)||(choice==0))
sound(3*i);
setcolor(1);
line(320-i,0,320-i,480);
line(320+i,0,320+i,480);
line(0,320-i,640,320-i);
line(0,160+i,640,160+i);
delay(2);
}
nosound();
closegraph();
if (choice == 1)
{
account a ;
a.display_account() ;
}
else
if (choice == 2)
{
initial ini ;
ini.display_list() ;
}
else
if (choice == 3)
{
account a ;
a.transaction() ;
}
else
if (choice == 4)
{
account a ;
a.new_account() ;
}
else
if (choice == 5)
edit_menu() ;
else
if (choice == 6)
help() ;
else
if (choice == 0)
{
break;
}
}
}
void toggle(int i,int temp)
{
char m1[]="
SEE ACCOUNT
",m2[]=" LIST OF
ACCOUNTS",m3[]=" TRANSACTIONS
", m4[]=" OPEN NEW
ACCOUNT",m5[]=" EDIT ACCOUNT",m6[]=" HELP
",
m7[]="
QUIT
";
if (i==0) i=7;
if (temp==0) temp=7;
box(temp,7);
switch(temp)
{
case 1: box(1,7);
setcolor(15);
outtextxy(320,90,m1);
break;
case 2: box(2,7);
setcolor(15);
break;
case 3: box(3,7);
setcolor(15);
break;
case 4: box(4,7);
setcolor(15);
break;
case 5: box(5,7);
setcolor(15);
break;
case 6: box(6,7);
setcolor(15);
break;
case 7: box(7,7);
setcolor(15);
break;
}
{
switch(i)
case 1: box(1,9);
setcolor(1);
break;
case 2: box(2,9);
setcolor(1);
break;
case 3: box(3,9);
setcolor(1);
break;
case 4: box(4,9);
setcolor(1);
break;
case 5: box(5,9);
setcolor(1);
break;
case 6: box(6,9);
setcolor(1);
break;
case 7: box(7,9);
setcolor(1);
break;
}
}
void selected(int i)
{
if(i==0) i=7;
delay(350);
setcolor(0);
line(180,60*(i+.5)-20,180,60*(i+.5)+20);
line(180,60*(i+.5)-20,460,60*(i+.5)-20);
setcolor(15);
line(460,60*(i+.5)-20,460,60*(i+.5)+20);
line(180,60*(i+.5)+20,460,60*(i+.5)+20);
line(461,60*(i+.5)-20,461,60*(i+.5)+21);
line(180,60*(i+.5)+21,461,60*(i+.5)+21);
delay(350);
setcolor(15);
line(180,60*(i+.5)-20,180,60*(i+.5)+20);
line(180,60*(i+.5)-20,460,60*(i+.5)-20);
setcolor(0);
line(460,60*(i+.5)-20,460,60*(i+.5)+20);
line(180,60*(i+.5)+20,460,60*(i+.5)+20);
line(461,60*(i+.5)-20,461,60*(i+.5)+21);
line(180,60*(i+.5)+21,461,60*(i+.5)+21);
}
void box(int i,int color)
{
setcolor(5);
line(180,60*(i+.5)-20,180,60*(i+.5)+20);
line(180,60*(i+.5)-20,460,60*(i+.5)-20);
line(460,60*(i+.5)-20,460,60*(i+.5)+20);
line(180,60*(i+.5)+20,460,60*(i+.5)+20);
setfillstyle(1,color);
floodfill(320,60*(i+.5),5);
setcolor(15);
line(180,60*(i+.5)-20,180,60*(i+.5)+20);
line(180,60*(i+.5)-20,460,60*(i+.5)-20);
setcolor(0);
line(460,60*(i+.5)-20,460,60*(i+.5)+20);
line(180,60*(i+.5)+20,460,60*(i+.5)+20);
line(461,60*(i+.5)-20,461,60*(i+.5)+21);
line(180,60*(i+.5)+21,461,60*(i+.5)+21);
}
//**********************************************************************
// CLASS CONTROL :: FUNCTION TO DISPLAY EDIT MENU
AND CALL OTHER
FUNCTIONS
//**********************************************************************
void control :: edit_menu(void)
{
char ch ;
while (1)
{
clrscr() ;
shape s ;
s.box(10,5,71,21,219) ;
gotoxy(31,16) ;
cout <<"Enter your choice: " ;
ch = getche() ;
if (ch == 27)
break ;
else
if (ch == '1')
{
initial ini ;
ini.modify() ;
break ;
}
else
if (ch == '2')
{
account a ;
a.close_account() ;
break ;
}
else
if (ch == '0')
break ;
}
}
//**********************************************************
// CLASS CONTROL :: FUNCTION TO DISPLAY HELP ABOUT
PROJECT
//**********************************************************
void control :: help(void)

{
clrscr() ;
shape s ;
s.box(2,1,79,25,218) ;
s.box(25,2,54,4,219) ;
textcolor(LIGHTBLUE+BLINK) ;
gotoxy(27,3); cprintf("WELCOME TO PROJECT BANKING") ;
delay(10) ;
gotoxy(10,5); cout <<" IN THIS PROJECT YOU
CAN
KEEP RECORD FOR DAILY ";
delay(10) ;
gotoxy(10,6); cout <<"\t\tBANKING TRANSACTIONS.
";
delay(10) ;
gotoxy(10,8); cout <<"- THIS PROGRAM IS CAPABLE OF
HOLDING ANY No. OF ACCOUNTS";
delay(10) ;
gotoxy(10,10); cout <<"1. In the first option the account of a
particular person";
delay(10) ;
gotoxy(10,11); cout <<" is displayed by giving simply the
account no. of that person." ;
delay(10) ;
gotoxy(10,13); cout <<"2. In second option you can see the list of
all the accounts." ;
delay(10) ;
gotoxy(10,15); cout <<"3. Through third option you can do
banking transactions" ;
delay(10) ;
gotoxy(10,16); cout <<" (Deposit/Withdraw)." ;
delay(10) ;
gotoxy(10,18); cout <<"4. In Fourth option you can open new
account." ;
delay(10) ;
gotoxy(10,19); cout <<" (NOTE: Opening amount i.e. , the first

deposit should not be " ;
delay(10) ;
gotoxy(10,20); cout <<" less than Rs.500/-";
delay(10);
gotoxy(10,22); cout <<"5. In Fifth option you can Modify or
Delete any account." ;
delay(10) ;
gotoxy(10,23); cout <<"6. In sixth option the help menu is
displayed ";
gotoxy(10,24); cout <<"7. This is the last option i.e., Quit (Exit to
Dos). " ;
delay(10) ;
textcolor(RED+BLINK) ; textbackground(WHITE+BLINK) ;
gotoxy(26,25) ; cprintf(" Press a key to continue ") ;
textcolor(LIGHTGRAY) ; textbackground(BLACK) ;
gotoxy(25,2) ;
getch() ;
getch() ;
for (int i=25; i>=1; i--)
{
delay(20) ;
gotoxy(1,i) ; clreol() ;
}
}
//******************************************************************
// CLASS INITIAL :: THIS FUNCTION RETURN LAST ACCOUNT
NO. IN THE FILE INITIAL.DAT
//******************************************************************
int initial :: last_accno(void)
{
fstream file ;
file.open("INITIAL.DAT", ios::in|ios::binary) ;
file.seekg(0,ios::beg) ;
int count=0 ;
while (file.read((char *) this, sizeof(initial)))
count = accno ;
file.close() ;
return count ;
}
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION RETURN RECORD NO. OF
THE GIVEN ACCOUNT NO. IN THE FILE INITIAL.DAT
//**********************************************************************
int initial :: recordno(int t_accno)
{
fstream file ;
int count=0 ;
{
count++ ;
if (t_accno == accno)
break ;
}
file.close() ;
return count ; }
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION DISPLAY THE ACCOUNT
FOR GIVEN ACCOUNT NO. FROM THE FILE INITIAL.DAT
//**********************************************************************
void initial :: display(int t_accno)
{
shape s ;
s.box(8,7,73,11,219) ;
fstream file ;
{
if (t_accno == accno)
{
gotoxy(8,5) ;
cout <<"ACCOUNT NO. " <<accno ;
gotoxy(10,8) ;
cout <<"Name : " <<name ;
gotoxy(10,9) ;
cout <<"Address : " <<address ;
gotoxy(10,10) ;
cout <<"Balance : " <<balance ;
break ;
}
}
file.close() ;
}
//*********************************************************************
// CLASS INITIAL :: THIS FUNCTION RETURN NAME FOR THE
GIVEN ACCOUNT NO. IN THE FILE INITIAL.DAT
//*********************************************************************
char *initial :: return_name(int t_accno)
{
fstream file ;
char t_name[30] ;
{
if (accno == t_accno)
{
strcpy(t_name,name) ;
break ;
}
}
file.close() ;
return t_name ;
}
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION RETURN ADDRESS FOR
//**********************************************************************
char *initial :: return_address(int t_accno)
{
fstream file ;
char t_address[60] ;
{
{
strcpy(t_address,address) ;
break ;
}
}
file.close() ;
return t_address ;
}
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION RETURN BALANCE FOR
//**********************************************************************
float initial :: give_balance(int t_accno)
{
fstream file ;
float t_balance ;
{
{
t_balance = balance ;
break ;
}
}
file.close() ;
return t_balance ;
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION RETURN 1 IF THE GIVEN
ACCOUNT NO. FOUND IN THE FILE INITIAL.DAT
//**********************************************************************
int initial :: found_account(int t_accno)
{
fstream file ;
int found=0 ;
{
{
found = 1 ;
break ;
}
}
file.close() ;
return found ;
}
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION DRAWS THE BOX FOR THE
LIST OF ACCOUNTS
//**********************************************************************
void initial :: box_for_list()
{
shape s ;
s.box(2,1,79,25,218) ;
s.line_hor(3,78,3,196) ;
s.line_hor(3,78,5,196) ;
s.line_hor(3,78,23,196) ;
textbackground(WHITE) ;
gotoxy(3,4) ;
for (int i=1; i<=76; i++) cprintf(" ") ;
textbackground(BLACK) ;
textcolor(BLACK) ; textbackground(WHITE) ;
gotoxy(4,4) ;
cprintf("ACCOUNT NO.
NAME OF
BALANCE") ;
int d1, m1, y1 ;
struct date d;
getdate(&d);
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
gotoxy(4,2) ;
cout <<"Date: " <<d1 <<"/" <<m1 <<"/" <<y1 ;
}
PERSON
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION DISPLAYS THE LIST OF
ACCOUNTS IN FILE INITIAL.DAT
//**********************************************************************
void initial :: display_list(void)
{
clrscr() ;
box_for_list() ;
int row=6, flag ;
fstream file ;
{
flag = 0 ;
delay(10) ;
gotoxy(7,row) ;
cout <<accno ;
gotoxy(25,row) ;
cout <<name ;
gotoxy(57,row) ;
cout <<balance ;
row++ ;
if (row == 23)
{
flag = 1 ;
row = 6 ;
gotoxy(4,24) ;
cout <<"Press any key to continue..." ;
getch() ;
clrscr() ;
box_for_list() ;
}
}
file.close() ;
if (!flag)
{
gotoxy(4,24) ;
cout <<"Press any key to continue..." ;
getch() ;
}
}
//*****************************************************************
// CLASS INITIAL :: THIS FUNCTION ADDS THE GIVEN DATA
INTO THE FILE
// INITIAL.DAT
//*****************************************************************
void initial :: add_to_file(int t_accno, char t_name[30], char
t_address[60], float t_balance)
{
accno = t_accno ;
strcpy(name,t_name) ;
strcpy(address,t_address) ;
balance = t_balance ;
fstream file ;
file.open("INITIAL.DAT", ios::out | ios::app|ios::binary) ;
file.write((char *) this, sizeof(initial)) ;
file.close() ;
}
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION DELETES RECORD FOR
THE GIVEN ACOUNT NO. FROM THE FILE INITIAL.DAT
//**********************************************************************
void initial :: delete_account(int t_accno)
{
fstream file ;
fstream temp ;
temp.open("temp.dat", ios::out|ios::binary) ;
while ( !file.eof() )
{
file.read((char *) this, sizeof(initial)) ;
if ( file.eof() )
break ;
if ( accno != t_accno )
temp.write((char *) this, sizeof(initial)) ;
}
file.close() ;
temp.close() ;
file.open("INITIAL.DAT", ios::out|ios::binary) ;
temp.open("temp.dat", ios::in|ios::binary) ;
temp.seekg(0,ios::beg) ;
while ( !temp.eof() )
{
temp.read((char *) this, sizeof(initial)) ;
if ( temp.eof() )
break ;
}
file.close() ;
temp.close() ;
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION UPDATE BALANCE FOR
THE GIVEN ACOUNT NO. IN THE FILE INITIAL.DAT
//**********************************************************************
void initial :: update_balance(int t_accno, float t_balance)
{
int recno ;
recno = recordno(t_accno) ;
fstream file ;
file.open("INITIAL.DAT", ios::out | ios::ate|ios::binary) ;
int location ;
location = (recno-1) * sizeof(initial) ;
file.seekp(location) ;
file.close() ;
}
//**********************************************************************
// CLASS INITIAL :: THIS FUNCTION MODIFIES THE RECORD
FOR THE GIVEN DATA IN THE FILE INITIAL.DAT
//**********************************************************************
void initial :: modify_account(int t_accno, char t_name[30], char
t_address[60])
{
int recno ;
recno = recordno(t_accno) ;
fstream file ;
file.open("INITIAL.DAT", ios::out | ios::ate|ios::binary) ;
strcpy(name,t_name) ;
strcpy(address,t_address) ;
int location ;
location = (recno-1) * sizeof(initial) ;
file.seekp(location) ;
file.close() ;
}
//**********************************************************************
//CLASS INITIAL :: THIS FUNCTION GIVE THE DATA TO
MODIFY THE RECORD IN THE FILE INITIAL.DAT
//**********************************************************************
void initial :: modify(void)
{
clrscr() ;
char t_acc[10] ;
int t, t_accno ;
gotoxy(1,1) ;
cout <<"PRESS (0) TO EXIT" ;
gotoxy(5,5) ;
cout <<"Enter the account no. " ;
gets(t_acc) ;
t = atoi(t_acc) ;
t_accno = t ;
if (t_accno == 0)
return ;
clrscr() ;
if (!found_account(t_accno))
{
gotoxy(5,5) ;
cout <<"\7Account not found" ;
getch() ;
return ;
}
shape s ;
s.box(2,2,79,24,218) ;
s.line_hor(3,78,4,196) ;
s.line_hor(3,78,22,196) ;
gotoxy(1,1) ;
d1 = d.da_day ;
//date of the system
m1 = d.da_mon ;
y1 = d.da_year ;
gotoxy(62,5) ;
cout <<"Date: "<<d1<<"/" <<m1 <<"/" <<y1 ;
char ch ;
display(t_accno) ;
account a ;
do
{
a.clear(5,13) ;
gotoxy(5,13) ;
cout <<"Modify this account (y/n): " ;
ch = getche() ;
if (ch == '0')
return ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
int modified=0, valid ;
char t_name[30], t_address[60] ;
gotoxy(5,15) ;
cout <<"Name : " ;
gotoxy(5,16) ;
cout <<"Address : " ;
do
{
a.clear(15,15) ;
a.clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER NAME or PRESS <ENTER> FOR NO
CHANGE" ;
valid = 1 ;
gotoxy(15,15) ;
gets(t_name) ;
strupr(t_name) ;
if (t_name[0] == '0')
return ;
if (strlen(t_name) > 25)
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7NAME SHOULD NOT BE GREATER

THAN 25") ;
getch() ;
}
} while (!valid) ;
if (strlen(t_name) > 0)
modified = 1 ;
do
{
a.clear(15,16) ;
a.clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER ADDRESS or PRESS <ENTER> FOR NO
CHANGE" ;
valid = 1;
gotoxy(15,16) ;
gets(t_address) ;
strupr(t_address) ;
if (t_address[0] == '0')
return ;
if (strlen(t_address) > 55)
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7SHOULD NOT BE BLANK OR
GREATER THAN 55") ;
getch() ;
}
} while (!valid) ;
if (strlen(t_address) > 0)
modified = 1 ;
if (!modified)
return ;
a.clear(5,23) ;
do
{
a.clear(5,18) ;
gotoxy(5,18) ;
cout <<"Do you want to save changes (y/n): " ;
ch = getche() ;
if (ch == '0')
return ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
modify_account(t_accno,t_name,t_address) ;
gotoxy(5,21) ;
cout <<"\7Record Modified" ;
gotoxy(5,23) ;
cout <<"press a key to continue..." ;
getch() ;
}
//****************************************************************
// CLASS ACCOUNT :: THIS FUNCTION CLEAR THE GIVEN
ROW AND COLUMNS
//****************************************************************
void account :: clear(int col, int row)
{
for (int i=col; i<=78; i++)
{
gotoxy(i,row) ;
cout <<" " ;
}
}
//*****************************************************************
// CLASS ACCOUNT :: THIS FUNCTION ADDS THE GIVEN DATA
INTO THE FILE BANKING.DAT
//*****************************************************************
void account :: add_to_file(int t_accno, int d1, int m1, int y1, char
t_tran, char t_type[10], float t_interest, float t_amount, float
t_balance)
{
fstream file ;
file.open("BANKING.DAT", ios::app|ios::binary) ;
accno = t_accno ;
dd = d1 ;
mm = m1 ;
yy = y1 ;
tran = t_tran ;
strcpy(type,t_type) ;
interest = t_interest ;
amount = t_amount ;
file.write((char *) this, sizeof(account)) ;
file.close() ;
}
//**********************************************************************
// CLASS ACCOUNT :: THIS FUNCTION DELETES THE RECORD
FOR GIVEN ACCOUNT NO. FROM FILE BANKING.DAT
//**********************************************************************
void account :: delete_account(int t_accno)
{
fstream file ;
file.open("BANKING.DAT", ios::in|ios::binary) ;
fstream temp ;
temp.open("temp.dat", ios::out|ios::binary) ;
while ( !file.eof() )
{
file.read((char *) this, sizeof(account)) ;
if ( file.eof() )
break ;
if ( accno != t_accno )
temp.write((char *) this, sizeof(account)) ;
}
file.close() ;
temp.close() ;
file.open("BANKING.DAT", ios::out|ios::binary) ;
temp.open("temp.dat", ios::in|ios::binary) ;
temp.seekg(0,ios::beg) ;
while ( !temp.eof() )
{
temp.read((char *) this, sizeof(account)) ;
if ( temp.eof() )
break ;
file.write((char *) this, sizeof(account)) ;
}
file.close() ;
temp.close() ;
}
//**********************************************************
// THIS FUNCTION ACCEPTS THE DATA TO ADD RECORDS IN
THE
// FILE BANKING.DAT
//**********************************************************
void account :: new_account(void)
{
char ch ;
int i, valid ;
clrscr() ;
initial ini ;
shape s ;
int d1, m1, y1 ;
struct date d;
getdate(&d);
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
int t_accno ;
t_accno = ini.last_accno() ;
t_accno++ ;
if (t_accno == 1)
{
ini.add_to_file(t_accno,"abc","xyz",1.1) ;
ini.delete_account(t_accno) ;
add_to_file(t_accno,1,1,1997,'D',"INITIAL",1.1,1.1,1.1) ;
delete_account(t_accno) ;
}
char t_name[30], t[10], t_address[60] ;
float t_bal=0.0, t_balance=0.0 ;
gotoxy(5,6) ;
cout <<"Date : "<<d1<<"/" <<m1 <<"/" <<y1 ;
gotoxy(5,8) ;
cout <<"Account no. # " <<t_accno ;
gotoxy(5,10) ;
cout <<"Name : " ;
gotoxy(5,11) ;
cout <<"Address : " ;
gotoxy(5,12) ;
cout <<"Name of Verifying person : " ;
gotoxy(5,14) ;
cout <<"Initial Deposit : " ;
do
{
clear(15,10) ;
clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER NAME OF THE PERSON" ;
valid = 1 ;
gotoxy(15,10) ;
gets(t_name) ;
strupr(t_name) ;
if (t_name[0] == '0')
return ;
if (strlen(t_name) == 0 || strlen(t_name) > 25)
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7NAME SHOULD NOT BE BLANK OR GREATER
THAN 25") ;
getch() ;
}
}
while (!valid) ;
do
{
clear(15,11) ;
clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER ADDRESS OF THE PERSON" ;
valid = 1 ;
gotoxy(15,11) ;
gets(t_address) ;
strupr(t_address) ;
if (t_address[0] == '0')
return ;
if (strlen(t_address) == 0 || strlen(t_address) > 55)
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7SHOULD NOT BLANK OR GREATER
THAN 55") ;
getch() ;
}
}
while (!valid) ;
do
{
char vari[30] ;
clear(31,12) ;
clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER NAME OF THE VERIFING PERSON" ;
valid = 1 ;
gotoxy(31,12) ;
gets(vari) ;
strupr(vari) ;
if (vari[0] == '0')
return ;
if (strlen(vari) == 0 || strlen(vari) > 25)
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7SHOULD NOT BLANK OR GREATER
THAN 25") ;
getch() ;
}
}
while (!valid) ;
do
{
clear(23,14) ;
clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER INITIAL AMOUNT TO BE DEPOSIT" ;
valid = 1 ;
gotoxy(23,14) ;
gets(t) ;
t_bal = atof(t) ;
t_balance = t_bal ;
if (t[0] == '0')
return ;
if (t_balance < 500)
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7SHOULD NOT LESS THAN 500
getch() ;
}
") ;
while (!valid) ;
clear(5,23) ;
add_to_file(t_accno,d1,m1,y1,t_tran,t_type,t_interest,t_amount,t_bala
nce);
}
//**********************************************************
// THIS FUNCTION DRAWS THE BOX FOR DISPLAYING
RECORD FROM
// FILE BANKING.DAT
//**********************************************************
void account :: box_for_display(int t_accno)
{
shape s ;
s.box(2,1,79,25,218) ;
s.line_hor(3,78,4,196) ;
s.line_hor(3,78,6,196) ;
s.line_hor(3,78,23,196) ;
textbackground(WHITE) ;
gotoxy(3,5) ;
for (int i=1; i<=76; i++) cprintf(" ") ;
textbackground(BLACK) ;
textcolor(BLACK) ; textbackground(WHITE) ;
gotoxy(4,5) ;
cprintf("DATE
PARTICULAR DEPOSIT
WITHDRAW
INTEREST BALANCE") ;
int d1, m1, y1 ;
struct date d;
getdate(&d);
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
gotoxy(63,2) ;
cout <<"Date: " <<d1<<"/" <<m1 <<"/" <<y1 ;
gotoxy(4,2) ;
cout <<"Account no. " <<t_accno ;
initial ini ;
char t_name[30] ;
strcpy(t_name,ini.return_name(t_accno)) ;
char t_address[60] ;
strcpy(t_address,ini.return_address(t_accno)) ;
gotoxy(25,2) ;
cout <<t_name ;
gotoxy(25,3) ;
cout <<t_address ;
}
//**********************************************************
// THIS FUNCTION DISPLAY RECORD FROM THE FILE
BANKING.DAT
//**********************************************************
void account :: display_account(void)
{
clrscr() ;
char t_acc[10] ;
int t, t_accno ;
gotoxy(1,1) ;
gotoxy(5,5) ;
gets(t_acc) ;
t = atoi(t_acc) ;
t_accno = t ;
if (t_accno == 0)
return ;
clrscr() ;
initial ini ;
if (!ini.found_account(t_accno))
{
gotoxy(5,5) ;
getch() ;
return ;
}
box_for_display(t_accno) ;
int row=7, flag = 0 ;
fstream file ;
while (file.read((char *) this, sizeof(account)))
{
{
flag = 0 ;
delay(10) ;
gotoxy(4,row) ;
cout <<dd <<"/"<<mm <<"/" <<yy ;
gotoxy(16,row) ;
cout <<type ;
if (tran == 'D')
gotoxy(30,row) ;
else
gotoxy(42,row) ;
cout <<long(amount*100)/100.0 ;
gotoxy(56,row) ;
cout <<long(interest*100)/100.0 ;
gotoxy(66,row) ;
cout <<long(balance*100)/100.0 ;
row++ ;
if (row == 23)
{
flag = 1 ;
row = 7 ;
gotoxy(4,24) ;
getch() ;
clrscr() ;
box_for_display(t_accno) ;
}
}
}
file.close() ;
if (!flag)
{
gotoxy(4,24) ;
getch() ;
}
}
//**********************************************************
// THIS FUNCTION RETURNS THE DIFFERENCE BETWEEN 2
DATES.
//**********************************************************
int account :: no_of_days(int d1, int m1, int y1, int d2, int m2, int y2)
{
static int month[] = {31,28,31,30,31,30,31,31,30,31,30,31} ;
int days = 0 ;
while (d1 != d2 || m1 != m2 || y1 != y2)
{
days++ ;
d1++ ;
if (d1 > month[m1-1])
{
d1 = 1 ;
m1++ ;
}
if (m1 > 12)
{
m1 = 1 ;
y1++ ;
}
}
return days ;
}
//**********************************************************
// THIS FUNCTION CALCULATES INTEREST.
//**********************************************************
float account :: calculate_interest(int t_accno, float t_balance)
{
fstream file ;
int d1, m1, y1, days ;
while (file.read((char *) this, sizeof(account)))
{
{
d1 = dd ;
m1 = mm ;
y1 = yy ;
break ;
}
}
int d2, m2, y2 ;
struct date d;
getdate(&d);
d2 = d.da_day ;
m2 = d.da_mon ;
y2 = d.da_year ;
float t_interest=0.0 ;
if ((y2<y1) || (y2==y1 && m2<m1) || (y2==y1 && m2==m1
&& d2<d1))
return t_interest ;
days = no_of_days(d1,m1,y1,d2,m2,y2) ;
int months=0 ;
if (days >= 30)
{
months = days/30 ;
t_interest = ((t_balance*2)/100) * months ;
}
file.close() ;
return t_interest ;
}
//**********************************************************
//
THIS
FUNCTION
MAKES
TRANSACTIONS
(DEPOSIT/WITHDRAW).
//**********************************************************
void account :: transaction(void)
{
clrscr() ;
char t_acc[10] ;
int t, t_accno, valid ;
gotoxy(1,1) ;
gotoxy(5,5) ;
gets(t_acc) ;
t = atoi(t_acc) ;
t_accno = t ;
if (t_accno == 0)
return ;
clrscr() ;
initial ini ;
{
gotoxy(5,5) ;
getch() ;
return ;
}
shape s ;
do
{
clear(5,18) ;
valid = 1 ;
gotoxy(5,18) ;
cout <<"Deposit or Withdraw (D/W) : " ;
t_tran = getche() ;
if (t_tran == '0')
return ;
t_tran = toupper(t_tran) ;
} while (t_tran != 'D' && t_tran != 'W') ;
do
{
clear(5,19) ;
clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER TRANSACTION BY
CHEQUE" ;
CASH
OR
< 1))
valid = 1 ;
gotoxy(5,19) ;
cout <<"(DD/Cheque) : " ;
gets(t_type) ;
strupr(t_type) ;
if (t_type[0] == '0')
return ;
if (strcmp(t_type,"DD") && strcmp(t_type,"CHEQUE"))
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7ENTER CORRECTLY
") ;
getch() ;
}
} while (!valid) ;
do
{
clear(5,21) ;
clear(5,23) ;
gotoxy(5,23) ;
cout <<"ENTER AMOUNT FOR TRANSACTION" ;
valid = 1 ;
gotoxy(5,21) ;
cout <<"Amount : Rs." ;
gets(tm) ;
t_amt = atof(tm) ;
t_amount = t_amt ;
if (tm[0] == '0')
return ;
if ((t_tran == 'W' && t_amount > t_balance) || (t_amount
{
valid = 0 ;
gotoxy(5,23) ;
cprintf("\7INVALID DATA ENTERED
") ;
getch() ;
}
} while (!valid) ;
char ch ;
clear(5,23) ;
do
{
clear(40,20) ;
valid = 1 ;
gotoxy(40,20) ;
cout <<"Save transaction (y/n): " ;
ch = getche() ;
if (ch == '0')
return ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
float t_interest ;
t_interest = calculate_interest(t_accno,t_balance) ;
if (t_tran == 'D')
t_balance = t_balance + t_amount + t_interest ;
else
t_balance = (t_balance - t_amount) + t_interest ;
ini.update_balance(t_accno,t_balance) ;
add_to_file(t_accno,d1,m1,y1,t_tran,t_type,t_interest,t_amount,t_bala
nce);
}
//**********************************************************
// THIS FUNCTION CLOSE THE ACCOUNT (DELETE
ACCOUNT).
//**********************************************************
void account :: close_account(void)
{
clrscr() ;
char t_acc[10] ;
int t, t_accno ;
gotoxy(1,1) ;
gotoxy(5,5) ;
gets(t_acc) ;
t = atoi(t_acc) ;
t_accno = t ;
if (t_accno == 0)
return ;
clrscr() ;
initial ini ;
{
gotoxy(5,5) ;
getch() ;
return ;
}
shape s ;
d1 = d.da_day ;
m1 = d.da_mon ;
y1 = d.da_year ;
gotoxy(62,5) ;
cout <<"Date: "<<d1<<"/" <<m1 <<"/" <<y1 ;
char ch ;
ini.display(t_accno) ;
do
{
clear(5,15) ;
gotoxy(5,15) ;
cout <<"Close this account (y/n): " ;
ch = getche() ;
if (ch == '0')
return ;
ch = toupper(ch) ;
} while (ch != 'N' && ch != 'Y') ;
if (ch == 'N')
return ;
ini.delete_account(t_accno) ;
delete_account(t_accno) ;
gotoxy(5,20) ;
cout <<"\7Record Deleted" ;
gotoxy(5,23) ;
getch() ;
}
//************************************************************
// THIS IS MAIN FUNCTION CALLING HELP AND MAIN MENU
FUNCTIONS
//************************************************************
void main(void)
//Main segment
{
int gdriver = DETECT, gmode, errorcode;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
gra1();
gra2();
control c ;
c.help() ;
c.main_menu() ;
}
//*************************************************************
//
INDIVIDUAL FUNCTION DEFINITIONS
//*************************************************************
void gra1()
//Function definition #1
{
clrscr();
char msg[33];
int gdriver=DETECT,gmode,errorcode,c1x,c2x,c3x,c4x,c5x,c6x;
int c1y,c2y,c3y,c4y,c5y,c6y;
c1x=c2x=270;
//
c1 c3
c3x=c4x=370;
// c5
c6
c5x=220;c6x=420;
//
c2 c4
c1y=c3y=20;
c2y=c4y=120;
c5y=c6y=70;
initgraph (&gdriver, &gmode," c:\\tc");
setfillstyle(1,8);
setcolor(8);
line(0,300,640,300);
setcolor(4);
//DRAW THE LOGO OF HSBC
setfillstyle(1,4);
setfillstyle(1,15);
setcolor(15);
outtextxy(230,200,"H");
outtextxy(290,200,"S");
//TO WRITE HSBC
outtextxy(350,200,"B");
outtextxy(410,200,"C");
setcolor(15);
gotoxy(20,23);
cout<<"LOADING . . .";
for (int x1=171,x2=171,y1=308,y2=331,y=1,S=0;x1<470;x1++,x2+
+,y++,S++)
{
setcolor(4);
line (x1,y1,x2,y2);
w=(x1-169)/3;
for (int i=34; i<=78; i++)
{
gotoxy(i,23) ;
cout <<" " ;
}
gotoxy(34,23); cout<<w<<"%";
if (x2>270) s=45; if (x2>370) s=10;
if (x2==320) delay(999); else
delay(s);
}
delay(800);
for (int i=27; i<=78; i++)
{
gotoxy(i,23) ;
cout <<" " ;
}
gotoxy(28,23);
cout<<"COMPLETE"; gotoxy(20,25);
cout<<"PRESS ANY KEY TO CONTINUE ";
getch();
cleardevice();
}
void gra2()
{
clrscr();
//Function definition *2
//To make a designer ellipse
int gd=DETECT,gm;
initgraph(&gd, &gm, "c:\\tc");
setcolor(8);
ellipse(320,240,0,360,300,150);
setcolor(5);
outtextxy(320,265,"F I N A L Y E A R ");
for (int stangle=0;!kbhit();stangle++)
{
setcolor(7);
ellipse(320,240,stangle,stangle+20,300,150);
ellipse(320,240,stangle+180,stangle+200,300,150);
delay(9);
setcolor(8);
ellipse(320,240,stangle-1,stangle+19,300,150);
ellipse(320,240,stangle-1+180,stangle+199,300,150);
}
closegraph();
}
TESTING REPORT
In testing report I can clarify only one thing that I have not found any
kind of error in this project related to coding, database, forms, modules,
reports, properties, MDI, logging in, tables etc.
I have completely run this project and have no comments about this
project (In Running Mode). There is no debugging process.
FUTURE APPLICATION
Regarding future application of this project , I have only
one answer that this project will be very helpful for the Bus
Reservation Management (BRM) . I can prove that this project will
never have an end related to the features of the project which is
liked by the customers in which they can feel much better than
they have no option and they will never have an option like this.
Another application of this project is that it could also be
used in other Traveling sectors ,besides this with the help of this
project we could easily manage and handle records which otherwise
would have been done thru manual systems which becomes very
time and resource consuming.
BIBLIOGRAPHY
I have created this project in C /C++. This can be done only with
the help of the book called understanding c/c++ by Yashwant
Kanitkar.

MCA Project Reprot

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

MCA Project Reprot

Diunggah oleh

Hak Cipta:

Format Tersedia

A

Bank Accounting Software

SRI BALAJI COLLEGE OF ENG. & TECH. , Jaipur

A well-educated engineer can do this work in a better way to find

This software stores data related to the offices of the agency,

Second Goal is to develop software that helps in the analysis of up

Demerits of Existing Systems

DEPARTMENT OF MASTER OF COMPUTER APPLICATION

SRI BALAJI COLLEGE OF ENG. & TECH.

MR. SURENDRA CHODHARY

We are greatly thankful to our project guide Mr.

Mr. SURENDRA CHOUDHARY

8.7 Displays /Output Screen

13...Account Table Screen

# Bibliography and References

The overall conclusion of our project Bank

access the database at a time by the help of

and money, personal frustration and unhappy

In order to conduct investigation for this project the

software organization, its client, or the market can

Does the proposed equipment have the

SOFTWARE ENGINEERING PARADIGM

work begins by establishing requirements for all

Testing: once code has been generated , programs

Introduction and purpose:

The purpose of this software is to eliminate the

representation and the components level

Scope of this project Bus Reservation

easy to get daily summary of figures in less

Customers can modify their accounts.

2. Objective of the project

3.1 Tools / Environment used:

3.2 Hardware Requirement:

Pentium 1 (100 MHz)

4. Complete Analysis & Design Document

In our project, Bank Accounting Software, customer is an input entity

Open New Account

Table 1: Account Table

Table 2: Customer Table

5.1 Entity Relationship Diagram (ERD)

The ERD of our project is as follows

5.2 Data Flow Diagram (DFD)

function presented in the DFD is contained in a process

The DFD of our project is as follows:

Level 2 Data Flow Diagram for the process Transaction

12. void display (int);

7. int found_account (int);

9. char * return_address (int);

3. int no_of_days (int, int, int, int, int, int);

2. void new_account (void)

4. void transaction (void)

function is to calculate the interest on monthly basis. The rate of

10. void box_for_display (int);

8.1 MAIN MENU SCREEN

Figure 7: Main Menu Screen

8.2 INPUT SCREEN

Figure 8: Open New Account Screen

8.3 TRANSACTION SCREEN

Figure 9: Transaction Screen

operator has to enter the amount for transaction i.e. Deposit or

8.4 EDIT MENU SCREEN

Figure 10: Edit Menu Screen

8.5 MODIFY ACCOUNT SCREEN