CHAPTER I

INTRODUCTIO

The project entitled as “GARMENTS SHOP MANAGEMENT

SYSTEM” is developed by using VB.Net as front end MS Access as back End.
The main aim of this project is to computerize the GARMENTS SHOP actives and
to provide details about the customer, Employees, stock and correspondence
activities and other relevant activities of shop which have been maintained
manually.

This project is developed as user friendly software so that it meets the user
needs at any time. This system is windows application software which attempts to
integrate all departments and functions across an organization onto a single
computer system that can serve all those department’s particular needs.

It maintains the following details. They are

● Employee Details
● Customer Details
● Stock Details
● Delivery Details
1.1 AIM AND OBJECTIVE OF THE PROJECT
The main aim of this project is to design and develop a fully computerized
management system for "TRENDY JEANS SHOP" This project has all necessary
modules that make the management an easy task. All problems faced in manual
based system shall be rectified by this project
The objectives are
⮚ A complete solution for Employee details.
1
⮚ To efficiently manage the Customer details.

2
 ⮚ To provide a good scope for efficient process of data.
⮚ To maintain a detailed staff attendance.
⮚ To help the management to take monthly reports.

1.2ORGANIZATION PROFILE

TRENDY JEANS GARMENTS SHOP is a growing Modern Tailoring

which was started in 2012. It is functioning for the past ten years. The concern is

located in the center of Udumalpet. The concern is one of the popular

GARMENTS SHOP in Udumalpet. There are about 2 floors from which user can

get all their needs under one roof.

The concern purchases the items from their supplier and stocks them. Also

the concern satisfies all customer needs. The customer details, complaint details

and rectification details are entered and designed according to the need of the

management of the concern.

The GARMENTS SHOP broadly covers all the Stitching work such as

Blouse, Sudithars, Mans Shirt, Pant, Kutras etc…. The TRENDY JEANS SHOP

is one of the best GARMENTS SHOP in Udumalpet.

1.3 OBJECTIVE

● To know the Customer details

● To overcome the problem of existing system
● To maintain the records of supplier, stock and customer details

3
● To generate the reports effectively

1.4 SYSTEM SPECIFICATIONS

1.4.1 HARDWARE SPECIFICATION

Processor : Intel Core i3

RAM : 2 GB

Hard disk drive : 80 GB of available hard-disk space

for installation

Clock Speed : 600 MHz

Monitor : Color Monitor

Printer : Laser Printer

Keyboard : Multi Media

Mouse : Optical Mouse

1.4.2 SOFTWARE SPECIFICATION

Technology : Microsoft Visual Studio 2010

Front end : VB.Net

Back end : MS Access

4
 CHAPTER II

SYSTEM

STUDY

2.2 EXISTING STUDY

In existing system, accessing the information is very slow, then it required

lot of manpower to organize the data for a consolidated report queries from the
higher authority are not easy to be replied. The stock details are also updated with
the new invoice value to the stock details record. This process may take more time
and risky for the staff, who is the in charge of these activities.

2.2.1 Disadvantages of Existing Study

⮚ Possibilities of redundant data

⮚ Constant update is difficult
⮚ They have to refer large amount of data for payment calculation
⮚ It is time consuming process end not easy

2.3 PROPOSED SYSTEM

When new stock came in to the gift shop the corresponding purchase files is
opened and the information regarding to the invoice are stored in the stock file, at
the same time the input details are also transferred to the payment file and recorded
automatically. This helps the user to process payment details very easily without
verifying the purchase file every time.

2.3.1 Advantages of Proposed System

⮚ It is completely menu driven

⮚ It is easy to use for the end user
5
⮚ It facilities the printing of reports

6
 ⮚ Validation checks are performed then and there
⮚ Data integrity is maintained

2.4 SOFTWARE SPECIFICATION

2.4.1 ABOUT VB.NET

2010

Microsoft .NET supports not only language independence, but also language
integration. This means that it can inherit from classes, catch exceptions, and take
advantage of polymorphism across different languages. The .NET Framework
makes this possible with a specification called the Common Type System (CTS)
that all .NET components must obey. For example, everything in.NET is an object
of a specific class that derives from the root class called System. Object. The CTS
supports the general concept of classes, interfaces, delegates (which support
callbacks), reference types, and value types.

2.5 COMPONENTS OF VB.NET

Garbage Collection

Garbage Collection is another new feature in Visual Basic.NET. The .NET

Framework monitors allocated resources, such as objects and variables. In
addition, the .NET Framework automatically releases memory for reuse by
destroying objects that are no longer in use. In Visual Basic.NET, the garbage
collector checks for the objects that are not currently in use by applications. When
the garbage collector comes across an object that is marked for garbage collection,
it releases the memory occupied by the object.

7
 Overloading

Overloading is another feature in Visual Basic.NET. Overloading enables us

to define multiple procedures with the same name, where each procedure has a
different set of arguments. Besides using overloading for procedures, and use it for
constructors and properties in a class.

Multithreading

Visual Basic.NET also supports multithreading. An application that supports

multithreading can handle multiple tasks simultaneously, it can use multithreading
to decrease the time taken by an application to respond to user interaction. To
decrease the time taken by an application to respond to user interaction, it must
ensure that a separate thread in the application handles user interaction.

Structured Exception Handling

Visual Basic.NET supports structured handling, which enables to detect and

remove errors at runtime. In Visual Basic.NET, need to use Try…Catch…Finally
statements to create exception handlers. Using Try…Catch…Finally statements, it
can create robust and effective exception handlers to improve the performance of
the application.

COMMON LANGUAGE RUNTIME

The common language runtime is the foundation of the .NET Framework. It

manages code at execution time, providing important services such as memory
management, thread management, and remoting and also ensures more security
and robustness.

NET CLASS LIBRARY

8
 It is a comprehensive, object-oriented collection of reusable types used to
develop applications ranging from traditional command-line or graphical user
interface (GUI) applications to applications based on the latest innovations
provided by ASP.NET, such as Web Forms and XML Web services.

The .NET Framework can be hosted by unmanaged components that load

the common language runtime into their processes and initiate the execution of
managed code, thereby creating a software environment that can exploit both
managed and unmanaged features. The .NET Framework not only provides several
runtime hosts, but also supports the development of third-party runtime hosts.

Internet Explorer is an example of an unmanaged application that hosts the

runtime (in the form of a MIME type extension). Using Internet Explorer to host
the runtime to enables embeds managed components or Windows Forms controls
in HTML documents.

2.6 FEATURES OF .NET

The .NET Framework is a new computing platform that simplifies

application development in the highly distributed environment of the Internet.

Common Language Runtime

One of the major components of the .NET Framework is the Common

Language Runtime, or CLR. The CLR provides a number of benefits to the
developer, such as exception handling, security, debugging, and versioning and
these benefits are available to any language built for the CLR. This means that the
CLR can host a variety of languages, and can offer a common set of tools across
those languages. Microsoft is to made VB, C++, and C# ”premier” languages for
the CLR, which means that these three languages fully support the CLR. In

9
addition, other vendors have signed up to provide implementations of other
languages, such as Perl, Python, and even COBOL.

When a compiler compiles for the CLR, this code is said to be managed
code. Managed code is simply code that takes advantage of the services offered by
the CLR. For the runtime to work with managed code, that code must contain
metadata. This metadata is created during the compilation process by compilers
targeting the CLR. The metadata is stored with the compiled code and contains
information about the types, members, and references in the code. Among other
things, the CLR uses this metadata to

▪ Locate classes
▪ Load classes
▪ Generate native code
▪ Provide security
Managed Execution

To understand how your VB.NET applications work, and just how much the
code differs from the VB code that Dorothy wrote in Kansas, it’s important to
understand managed code and how it works. To use managed execution and get the
benefits of the CLR, you must use a language that was built for, or targets, the
runtime. Fortunately for you, this includes VB.NET. In fact, Microsoft wanted to
make sure that VB.NET was a premier language on the .NET platform, meaning
that Visual Basic could no longer be accused of being a “toy” language.

The runtime is a language-neutral environment, which means that any

vendor can create a language that takes advantage of the runtime’s features.
Different compilers can expose different amounts of the runtime to the developer,
so the tool you use and the language in which you write might still appear to work

10
somewhat differently. The syntax of each language is different, of course, but
when the compilation process occurs, all code should be compiled into something
understandable to the runtime.

Microsoft Intermediate Language (MSIL)

One of the more interesting aspects of .NET is that when you compile your
code, you do not compile to native code. Before you VB developers panic and fear
that you are returning to the days of interpreted code, realize that the compilation
process translates your code into something called Microsoft intermediate
language, which is also called MSIL or just IL. The compiler also creates the
necessary metadata and compiles it into the component. This IL is CPU
independent. After the IL and metadata are in a file, this compiled file is called the
PE, which stands for either portable executable or physical executable, depending
on whom you ask. Because the PE contains your IL and metadata, it is therefore
self-describing, eliminating the need for a type library or interfaces specified with
the Interface Definition Language (IDL).

The Just-In-Time Compiler

Your code does not stay IL for long, however. It is the PE file, containing
the IL that can be distributed and placed with the CLR running on the .NET
Framework on any operating system for which the .NET framework exists,
because the IL is platform independent. When you run the IL, however, it is
compiled to native code for that platform. Therefore, you are still running native
code; you are not going back to the days of interpreted code at all. The compilation
to native code occurs via another tool of the .NET Framework: the Just-In-Time
(JIT) compiler. With the code compiled, it can run within the Framework and take
advantage of low level features such as memory management and security.

11
 The compiled code is native code for the CPU on which the .NET
Framework is running, meaning that you are indeed running native code instead of
interpreted code. A JIT compiler will be available for each platform on which the
.NET Framework runs, so you should always be getting native code on any
platform running the .NET Framework. Remember, today this is just Windows, but
this could change in the future.

Classes

Most Visual Basic developers are familiar with classes. Classes are
definitions or blueprints of objects that will be created at runtime. Classes define
the properties, methods, fields, and events of objects.

You could actually instantiate the interface in VB6, but because it did not
have any implementation code, there was no point in doing so. In VB.NET, you
can create a class that has implementation code instead of just the interface, and
then mark the class as abstract. Now, other classes can inherit from that abstract
class and use the implementation in it or override the implementation as needed.

Interfaces

Interfaces in VB.NET are like the interfaces in previous versions of VB:

They are definitions of a class without the actual implementation. Because there is
no implementation code, you cannot instantiate an interface, but must instead
implement it in a class. There is one exception to the “no implementation code in
an interface” rule: In VB.NET, you can define what are called static members.
These can have implementation code.

Value Types

12
 In .NET languages, a standard variable type, such as an integer, is native to
the language, and it is passed by value when used as an argument. Objects, on the
other hand, are always passed by reference. However, a value type is a user-
defined type that acts much like an object, but is passed by value. In reality, value
types are stored as primitive data types.

The .NET Framework is made up of four parts, as shown in the Common

Language Runtime, a set of class libraries, a set of programming languages, and
the ASP.NET environment. The .NET Framework was designed with three goals
in mind. First, it was intended to make Windows applications much more reliable,
while also providing an application with a greater degree of security. Second, it
was intended to simplify the development of Web applications and services that
not only work in the traditional sense, but on mobile devices as well.

1) INTEROPERABILITY

Because interaction between new and older applications is commonly

required, the .NET Framework provides means to access functionality that is
implemented in programs that execute outside the .NET environment.

2) COMMON RUNTIME ENGINE (CLR)

The Common Language Runtime (CLR) is the virtual machine component

of the .NET framework. All .NET programs execute under the supervision of the
CLR, guaranteeing certain properties and behaviours in the areas of memory
management, security, and exception handling.

13
3) BASE CLASS LIBRARY

The Base Class Library (BCL), part of the Framework Class Library (FCL),
is a library of functionality available to all languages using the .NET Framework.
The BCL provides classes which encapsulate a number of common functions,
including file reading and writing, graphic rendering, database interaction and
XML document manipulation.

4) SIMPLIFIED DEPLOYMENT

Installation of computer software must be carefully managed to ensure that it

does not interfere with previously installed software, and that it conforms to
security requirements. The .NET framework includes design features and tools that
help address these requirements.

5) SECURITY

The design is meant to address some of the vulnerabilities, such as buffer

overflows, that have been exploited by malicious software. Additionally, .NET
provides a common security model for all applications.

6) PORTABILITY

The design of the .NET Framework allows it to theoretically be platform

agnostic, and thus cross-platform compatible. That is, a program written to use the
framework should run without change on any type of system for which the
framework is implemented.

14
7) VIRTUAL EXECUTION SYSTEM (VES)

The VES loads and executes CLI-compatible programs, using the metadata
to combine separately generated pieces of code at runtime.

All compatible languages compile to Common Intermediate Language

(CIL), which is an intermediate language that is abstracted from the platform
hardware. When the code is executed, the platform-specific VES will compile the
CIL to the machine language according to the specific hardware.

8) CARBAGE COLLECTION

The .NET Garbage Collector (GC) is a non-deterministic, compacting,

mark-and-sweep garbage collector. The GC runs only when a certain amount of
memory has been used or there is enough pressure for memory on the system.
Since it is not guaranteed when the conditions to reclaim memory is reached, the
GC runs are non-deterministic.

2.7 ASSEMBLIES

An assembly is a collection of types and resources that forms a logical unit

of functionality. All types in the .NET Framework must exist in assemblies; the
common language runtime does not support types outside of assemblies. Each time
you create a Microsoft Windows Application, Windows Service, Class Library, or
other application with Visual Basic .NET, you're building a single assembly. Each
assembly is stored as an .exe or .dll file.

The name of an assembly consists of four parts.

1. The short name. On Windows this is the name of the Portable

Executable (PE) file without the extension.

15
 2. The culture. This is an RFC 1766 identifier of the locale for the assembly. In
general, library and process assemblies should be culture neutral; the culture
should only be used for satellite assemblies.
3. The version. This is a dotted number made up of four values — major,
minor, build and revision.
4. A public key token. This is a 64-bit hash of the public key that corresponds
to the private key used to sign[1] the assembly. A signed assembly is said to
have a strong name.
2.8 COMMON TYPE SYSTEM

It describes set of data types that can be used in different .Net languages in
common. (i.e), CTS ensures that objects written in different .Net languages can
interact with each other.

For Communicating between programs written in any .NET complaint language,

the types have to be compatible on the basic level.

The common type system supports two general categories of types:

Value types:

Value types directly contain their data, and instances of value types are either
allocated on the stack or allocated inline in a structure. Value types can be built-in
(implemented by the runtime), user-defined, or enumerations.

Reference types:

Reference types store a reference to the value's memory address, and are allocated
on the heap. Reference types can be self-describing types, pointer types, or
interface types. The type of a reference type can be determined from values of self-

16
describing types. Self-describing types are further split into arrays and class types.
The class types are user-defined classes, boxed value types, and delegates.

2.9 CROSS LANGUAGE INTEROPERABILITY

The common language runtime's built-in support for language

interoperability and explains the role that the Common Language Specification
(CLS) plays in enabling guaranteed cross-language interoperability. Language
interoperability is the ability of code to interact with code that is written by using a
different programming language. Language interoperability can help maximize
code reuse and improve the efficiency of the development process.
Because developers use a wide variety of tools and technologies, each of
which might support different features and types, it has historically been difficult
to ensure language interoperability. However, language compilers and tools that
target the common language runtime benefit from the runtime's built-in support for
language interoperability.
The common language runtime provides the necessary foundation for
language interoperability by specifying and enforcing a common type system and
by providing metadata. Because all languages targeting the runtime follow the
common type system rules for defining and using types, the usage of types is
consistent across languages. Metadata enables language interoperability by
defining a uniform mechanism for storing and retrieving information about types.
Compilers store type information as metadata, and the common language runtime
uses this information to provide services during execution; the runtime can manage
the execution of multi language applications because all type information is stored
and retrieved in the same way, regardless of the language the code was written in.
Managed code benefits from the runtime's support for language interoperability
in the following ways:

17
  Types can inherit implementation from other types, pass objects to another
type's methods, and call methods defined on other types, regardless of the
language the types are implemented in.
 Debuggers, profilers, or other tools are required to understand only one
environment—the Microsoft intermediate language (MSIL) and metadata for
the common language runtime—and they can support any programming
language that targets the runtime.
 Exception handling is consistent across languages. Your code can throw an
exception in one language and that exception can be caught and understood
by an object written in another language.

2.10 MS ACCESS

Introduction to Database

A database is a collection of information related to a particular Subject or

purpose: such as customer orders or maintaining a music collection. A database is
a program for storing and manipulating data. In a database, we can organize a set
of data in some way and get that information easily.

Entity

This is to describe the conceptual data units or objects represented as

rectangles.

Relationship

It represents real-world associates among one or more entities. These are

represented as diamonds.

18
 Uniqueness and keys

In MS-Access, the Master Database (MDB) file contains number of tables.

Each table contains rows and columns. The relational model dictates that every
row in a database must be unique.

Primary key

A primary key is made up of one or more attributes whose value or values

uniquely identified each record in a table. In a relationship, a primary key is used
to refer to specific records in a table. A primary key is called a foreign key, when it
is referred to from another table.

Data integrity

Enforcing data integrity involves presenting the consistency and correctness

of data stored in the database by

 Validating the contents of individual fields

 Validating data in one table with respect to one another
 Verifying field values with respect to another.

Data types in MS - Access

Some of the data types in Access are

• Text
• Currency
• Date / time
• Logical
• OLE Object Picture

19
Queries

Query is used to extract information from the table based on performing

certain conditions. This is mainly used for reports. In this query we can include
more than one table at a time.

Forms

A form is used to get a record from user in specific format. Using forms we
can display records in specific manner. In forms, we can set lay out properties and
data properties. Using forms we can design the fields in text box and check box for
selecting a list of options and radio or push buttons used for selecting a single
option at a time. Reports

In MS-Access, the records in database are prepared for reports. Each record
is set in specific place. In the reports, we can include needed fields only. After
viewing the reports, the records can be printed in a specific manner.

Actives Data Objects (ADO)

The ADO object model is actually quite simple-there is only six total
objects. The Connection object sets up a link between program and the data source.
This object contains all of the necessary configuration information and acts as a
gateway for all of the other ADO objects. The connection object is mandatory-all
implementations of ADO must support it.

Each connection object may have an associated collection of Error objects.

ADO utilizes this collection when the connection returns more than one error
message at a time. This collection is optional.

20
 The command object represents a SQL statement or stored procedure that
software executes against the data source. Use of command objects is optional-data
can be extracted directly from a Connection object. If desired. Command objects
may have an associated collection of parameter objects that provide additional
information to the data source when executing the command. The Parameter
collection is optional.

Each command executes results in a Record set containing the results of a

query. This object is a mandatory part of ADO.

21
 CHAPTER III

SYSTEM DESIGN AND DEVELOPMENT

5.1 INPUT DESIGN

Design is the first step into the development phase for any engineered
product or system. Design is a creative process. A good design is the key to
effective system. The term "Design" is defined as "The process of applying various
techniques and principles for the purpose of defining a process or a system in
sufficient detail to permit its physical realization". It may be defined as a process
of applying various techniques and principles for the purpose of defining a device,
a process or a system in sufficient detail to permit its physical realization. Software
design sits at the technical kermel of the software engineering process and is
applied regardless of the development paradigm that is used. The system design
develops the architectural detail required to build a system or product. As in the
case of any systematic approach, this software too has undergone the best possible
design phase fine tuning all efficiency, performance and accuracy levels. The
design phase is a transition from a user oriented document to a document to the
programmers or database personnel. System design goes through two phases of
development: Logical and Physical Design.

The design of input focuses on controlling the amount of input required,

controlling the errors, avoiding delay, avoiding extra steps and keeping the process
simple. The input is designed in such a way so that it provides security and ease of
use with retaining the privacy. Input Design considered the following things:

• What data should be given as input?

• How the data should be arranged or coded?

22
 • The dialog to guide the operating personnel in providing input.

5.2 OUTPUT DESIGN

A quality output is one, which meets the requirements of the end user and
presents the information clearly. In output design it is determined how the
information is to be displaced for immediate need and also the hard copy output. It
is the most important and direct source information to the user. Efficient and
intelligent output design improves the system's relationship to help user decision-
making.

Designing computer output should proceed in an organized, well thought out

manner; the right output must be developed while ensuring that each output
element is designed so that people will find the system can use easily and
effectively. When analysis design computer output, they should

• Identify the specific output that is needed to meet the requirements.

• Select methods for presenting information.
• Create document, report, or other formats that contain information produced
by the system.

5.3 DATABASE DESIGN:

The data base design has the aim to improve the existing system. The new
system is developed by the proposed system. The idea of systems has become most
practicable and necessary in conceptualizing the interrelationships and integration
of operators especially when using computers, it involves à set of technique that
helps in solving problems, In a database environment common data are available
and are used by several users.

23
 Thus the goal of a relational data is to generate a set of relational data is to
generate a set creational schemes that allow us to store information without
unnecessary reluctance yet allow us to retrieve easily one approach is to design
schemes that are in an appropriate normal form.

In this module we had designed database, which is free if unnecessary

redundancies and ahide with all the conditions of the third normal form. It is very
important to generate data that adheres to certain rules as determined by the data
base administrators or application developer.

The relational database consists of collection of tables, each of which is

assigned a unique name, A row in a table represents the relationship among a set of
values. Since a table is a set of such relationships, there is a close correspondence
between the concept of the table and the mathematical concept of the relation from
which the relational model takes its name.

A relational scheme is a list of attributes and their corresponding domains.

The use of common attributes in relational schemes is a list of attributes relational
schemes is a way of relating tables of distinct relations. These common attributes
are called keys. The relations that will allow us to store information without
redundancy yet allow us to store and retrieve information easily.

24
 CHAPTER IV

SYSTEM TESTING AND IMPLEMENTATION

6.1.INTRODUCTION

Testing is the last stage of software development before we release the

product to the customer. It is the process of exercising of evaluating a system by
manual or automatic means to verity that it satisfies between expected and actual
results. The testing activities aimed at convincing the customer through
demonstration and actual use that the software is solution to the original problem
and that both the product and processes that created it are of high quality. It is do
find the operational reliability of the system and to eliminate any residual errors
from previous stages.

• To affirm the quality of the product

• To find and eliminate any residual errors form previous stages.
• To demonstrate the presence of the specified function in the produce.
• To validate the software as solution to the original problem.
• To find operational reliability of the system.

6.2. SYSTEM DEVELOPMENT

The common view of testing held by users is that it is performed to prove

that there are o errors in a program. This is extremely difficult since designer
cannot prove to be one bundled percent accurate. Therefore, the most useful and
practical approach is with the understanding that testing is the process of executing
a program with explicit intention of finding errors that make the program fail.
Testing has its own cycle. The testing process begins with the product
requirements phase and from there parallels the entire development process. In
25
other words, for each phase of the development process there is an important
testing activity. Successful testing requires a methodical approach. It requires to
focus on basic critical factors: Planning Project and process control Risk
management Inspections Measurement tools Organization and professionalism

6.3. SYSTEM SECURITY:

Test plan: Before going for testing, first we have to decide upon the type of
testing to be carried out. The following factors are taken into consideration: To
ensure that information properly flows into and out of program To find out whether
the local data structures maintains its integrity. during all steps in an algorithm
execution To ensure that the module operate properly at boundaries established to
limit or restrict processing To find out whether error - handling paths are working
correctly or JOU To find out whether the values are correctly updated or not Check
for validations Unit Testing: Unit or module testing is the process of testing the
individual components (subprograms or procedures) of a program. The purpose is
to discover discrepancies between the modules interface specification and its actual
behavior. In our system each module namely

(i) Search module

(ii) Request module

(iii) Order module Must be tested independently for validation.

Integration Testing:

Integration testing is the process of combining and testing multiple

components together. The primary objective of integration testing is to discover
errors in the interfaces between the components. In our system each of the modules

26
mentioned above, are tested tor checking the integration between them, after each
of them are tested Individually. System Testing: Validation testing provides the
final assurance that software meets all functional, behavioral and performance
requirement. The software once validated must be combined with other system
elements, System testing verifies that as elements combine properly and that
overall system function and performance is achieved.

6.4 SYSTEM TESTING DEVELOPMENT

It is the systematic technique for constructing the program structure and for
conducting tests to uncover errors associated with interfacing. The objective is to
take module and build program structure that has been dictated by design. These
are two types of integration. Incremented Integration Non-incremented integration.
Acceptance testing is carried out to evaluate the finished product. This is done by
the sponsor and may involve executing typical transactions or using the system on
site on a trial basis. It is actually a series of different tests whose primary propose
is fully existing the computer based system. Although each test has a different
purpose all work should verify that system. The most crucial stage is achieving a
successful new system and is giving the user's confidence is that the new system
will work and be effective in the implementations stage.

27
 CHAPTER V

CONCLUSION

5.1 CONCLUSION

To conclude, this project is very flexible and user-friendly. This project is

developed such that it can be executed in any system. Security is also maintained.
This system is protected from any unauthorized person to access the system. The
software was tested thus providing maximum load to the server and was found
working fast and effective.

The proposed system is developed keeping in mind all the demerits of

existing system. It is developed to eliminate all the demerits and adding some extra
features. The system has been designed and developed flexibly according to the
current requirement of the user. As the information requirements may still increase
in the near future. Further such development can be attempted.

5.2 FUTURE ENHANCEMENTS

Every application has its own merits and demerits. The project has covered
almost all the requirements. Further requirements and improvements can easily be
done since the coding is mainly structured or modular in nature. Changing the
existing modules or adding new modules can append improvements. Further
enhancements can be made to the application, so that the functions are very
attractive and useful manner than the present one.

28
 BIBLIOGRAPHY

BOOK REFERENCES

1) Daniel Cazzulino, Victor Garcia Aprea, James Greenwood, and Chris Hart,

‘Beginning Visual Basic Programming in VB.NET: From Novice to

Professional’, Fifth edition, Feb 28, 2005.

2) Bill Evjen, Billy Hollis, Bill Sheldon, and Kent Sharkey, ‘Professional VB

2005 with .NET 3.0 (Programmer to Programmer)’, Second edition, Jun 5,

2007.

3) Damon Allison, Andy Olsen, and James Speer, Visual Basic .NET Class

Design Handbook: Coding Effective Classes’ Sep 5, 2003.

4) Roger S. Pressman, ‘Software Engineering: A Practioner’s Approach’,

McGraw-Hill International Edition, Fifth edition, 2001.

5) Benjamin Nevarez, ‘Inside the SQL Server Query Optimize’, Red gate

books , 2011

WEB REFERENCES
1) www.net-tutorials.com
2) www.tutorialspoint.com/vb.net
3) www.visual-basic-tutorials.com
4) www.vbtutor.net
5) www. sqlmag.com

29
 APPENDICES

A. DATA FLOW DIAGRAM

Level 0

Id, Password View

Admin Login
Purchase entry

Stock Details

Registration
Id, Name Details

Customer Customer details

Register

Sales

Quantity Purchased

Level 1
Purchased
Accessories

Amount

Billing Update

Remaining Quantity

Stock Details
30
 Level 2

Id, Name Supplier

Supply Customer
Accessories
Id, Name
Purchased Register
date ed date
R

Purchase details
Store
Login
Admin

Purchased
Quantity

Total
Amount
Bill
Pay and Update Amount

Remaining Quantity

Update

Stock Details
Updated Quantity

31
 SYSTEM FLOW DIAGRAM
User Input

No
Is Valid
Yes

Stock Supplier Purchase Customer Billing

Stock Supplier Purchase Customer Billing

Details Details Details Details Details

Process

Supplier Customer Delivery

Stock Report Purchase
Report
Report Report Report

32
 C. ENTITY RELATIONSHIP DIAGRAM
Quantity

Address Accessories
SID
Accessories Name
id
SName

Supplier View Purchased

Accessories

Available Phone
Accessories Number
Price

View Admin Update

Accessories
Accessories Accessories
Name
id Name
Billing

Price Stock
Update

Bill ID
Total Price
Quantity
Date
Customer Accessories
id id

Customer Updated
Date
name Stock

Sales Customer

33
Address Phone
Number
D. TABLE STRUCTURE

1) Table Name: Customer Details

Primary Key: CID

Field Data Type Size Description

Name
CID Nvarchar 15 Customer Identification Number

Cname Nvarchar 30 Name of the Customer

Addr Nvarchar 50 Address

Phno Bigint 20 Phone number

Rdate Date Date of Registration

34
2) Table Name: Order Details

Primary Key: PID

Field Data Size Description

Type
Name

OID Nvarchar 15 Order Identification Number

Cname Nvarchar 30 Name of Cloth

ItemCnt Float 20 Item Counting

Price Float 20 Price of the Cloth Stitching

35
3) Table Name: Supplier details

Primary Key: SID

Field Name Data Type Size Description

SID nvarchar 15 Supplier ID

Sname nvarchar 30 Name of Supplier

Addr nvarchar 50 Address of the Supplier

Phno bigint 20 Phone number of the Supplier

Productype nvarchar 20 Available Accessories Supplied

36
4) Table Name: Stock Details

Foreign Key: PID

Field Data Type Size Description

Name
PID nvarchar 15 Grocery Item Identification Number

Pname nvarchar 30 Name of Grocery Item

Uqty Float 20 Updated Quantity of the Grocery

Item
Price Float 20 Price of the Grocery Item

Udate Date Updated date

37
5) Table Name: Billing Details

Field Data Type Size Description

Name
BID Int 10 Bill Identification Number

CID Nvarchar 15 Customer Identification Number

PID Nvarchar 15 Cloth Item Identification Number

Pname Nvarchar 30 Name of cloth Item

Qty Float 20 Quantity of the Item

Price Float 20 Price of the cloth stitching Item

Tot Float 20 Total

Bdate Date Billing date

38
6) Table Name: Employee

details Primary key:Ecode

Description: This table holds the details about the employees of the company.

Field Data Widt Constrai Description

name type h ns
Ecode Varchar 0 Not Null Employer code
8
Ename Char 2 Not Null Employer name
5
Edd Varchar 3 Not Null Employer address
0
Ehone Integer 1 Not Null Employer phone
0
Esal Integer 1 Not Null Employee Salary
0
Email Text 2 Not Null Email ID
0
Emp Bank Text 1 Not Null Bank Name
0
Account No Double 4 Not Null Bank A/C No
0

39
E. SAMPLE

SCREENS: LOGIN

PAGE

40
Order Details

41
Tailor Master Details

42
Alteration Register

43
Bill Details

44
Computerized Billing:

45
Measurement Details

46
F. SAMPLE CODING:

Imports System.Data
Imports System.Data.SqlClient
Public Class frmBuyer
Dim con As New SqlConnection
Dim cmd As New SqlCommand
Dim da As New SqlDataAdapter("select *from tblBuyerDetails1", con)
Dim ds As New DataSet
Dim dbind As New BindingSource

Dim a As Integer = 0

Private Sub frmBuyer_Load(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles MyBase.Load
LoadDatabase()
Load1()
clear()
End Sub
Private Sub LoadDatabase()
con.Close()
con.ConnectionString = "Data Source=.\SQLEXPRESS;Initial
Catalog=Geeva;Integrated Security=True"
con.Open()
End Sub
Public Sub Load1()
ClearGridView()

47
 LoadDatabase()
da.Fill(ds,
"tblBuyerDetails1")
dbind.DataSource = ds
dbind.DataMember =
ds.Tables(0).ToString()
DataGridView1.DataSource = dbind
End Sub
Private Sub ClearGridView()
For Each row As DataGridViewRow In
DataGridView1.Rows DataGridView1.Rows.Remove(row)
Next
End Sub

Private Sub btInsert_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btInsert.Click
LoadDatabase()
cmd.Parameters.Clear(
)
Try
cmd.Connection = con
cmd.CommandType = CommandType.StoredProcedure
cmd.CommandText = "spInsertBuyerDetails1"
'cmd.Parameters.AddWithValue("@Bno", txtbuyerid.Text)
cmd.Parameters.AddWithValue("@Bname", txtBuyername.Text)
cmd.Parameters.AddWithValue("@Conno", txtcontact.Text)
cmd.Parameters.AddWithValue("@Email", txtmail.Text)

48
cmd.Parameters.AddWithValue("@Address", txtaddress.Text)
cmd.Parameters.AddWithValue("@RDate", DateTimePicker1.Value)
'cmd.Parameters.AddWithValue("@Accname", txtaccname.Text)

49
 'cmd.Parameters.AddWithValue("@Accno", txtaccno.Text)
'cmd.Parameters.AddWithValue("@Bankname", txtbankname.Text)
'cmd.Parameters.AddWithValue("@Branchname", txtbranchname.Text)
cmd.ExecuteNonQuery()
MsgBox("Details of Buyer are Successfully Inserted", vbInformation,
"Successfully Inserted")
con.Close()

Catch ex As Exception
MsgBox("Details are not Inserted! Please Try Later", vbInformation, "Error
In Inserting Buyer Details")
End Try
ClearGridView()
Load1()
clear()
End Sub

Private Sub btClear_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btClear.Click
txtbuyerid.Clear()
txtBuyername.Clear()
txtcontact.Clear()
txtmail.Clear()
txtaddress.Clear()
'txtaccname.Clear()
'txtaccno.Clear()
'txtbankname.Clear()
'txtbranchname.Clear(
50
)

51
 End Sub

Private Sub DataGridView1_SelectionChanged(ByVal sender As Object, ByVal

e As System.EventArgs) Handles DataGridView1.SelectionChanged
Try
Dim dgv As DataGridView = TryCast(sender, DataGridView)
If dgv IsNot Nothing AndAlso dgv.SelectedRows.Count > 0 Then
Dim row As DataGridViewRow = dgv.SelectedRows(0)
If row IsNot Nothing Then

txtbuyerid.Text = row.Cells(0).Value.ToString()
txtBuyername.Text = row.Cells(1).Value.ToString()
txtcontact.Text = row.Cells(2).Value.ToString()
txtmail.Text = row.Cells(3).Value.ToString()
txtaddress.Text = row.Cells(4).Value.ToString()
DateTimePicker1.Value =
row.Cells(5).Value.ToString() 'txtaccname.Text =
row.Cells(5).Value.ToString() 'txtaccno.Text =
row.Cells(6).Value.ToString() 'txtbankname.Text =
row.Cells(7).Value.ToString() 'txtbranchname.Text =
row.Cells(8).Value.ToString()

End If
End If
Catch ex As Exception
End Try
End Sub
52
 Private Sub btUpdate_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles btUpdate.Click
LoadDatabase()
Me.Refresh()
'Dim answer As
Long Try
cmd.Parameters.Clear()

'answer = MsgBox("Are you sure to Updating Data?", vbYesNo, "Updating

Record")
'If (answer = vbYes) Then
cmd.Connection = con
cmd.CommandType = CommandType.StoredProcedure
cmd.CommandText = "spUpdateBuyerDetails1"
'cmd.Parameters.Add("@ProductCode", SqlDbType.NVarChar).Value =
ttProductCode.Text

cmd.Parameters.AddWithValue("@Bname", txtBuyername.Text)
cmd.Parameters.AddWithValue("@Conno", txtcontact.Text)
cmd.Parameters.AddWithValue("@Email", txtmail.Text)
cmd.Parameters.AddWithValue("@Address", txtaddress.Text)
cmd.Parameters.AddWithValue("@RDate", DateTimePicker1.Value)
'cmd.Parameters.AddWithValue("@Accname", txtaccname.Text)
'cmd.Parameters.AddWithValue("@Accno", txtaccno.Text)
'cmd.Parameters.AddWithValue("@Bankname", txtbankname.Text)
'cmd.Parameters.AddWithValue("@Branchname", txtbranchname.Text)
cmd.Parameters.Add("@Bno", SqlDbType.NVarChar).Value =
txtbuyerid.Text
53
 cmd.ExecuteNonQuery()
MsgBox("Buyer Details Updated", vbInformation, "Succesfully Updated")
con.Close()
ClearGridView()
Load1()
Me.Refresh()
'Else
'txtSerialNo.Focus()
'End If
Catch ex As Exception

MsgBox("Unable to Update Record! Please Try Later", vbInformation,

"Error in Updating Record")
End
Try
clear()
End Sub

Private Sub btDelete_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btDelete.Click
LoadDatabase()
Me.Refresh()
' Dim answer As
Long Try
cmd.Parameters.Clear()

'answer = MsgBox("Are you sure to Deleting Data?", vbYesNo, "Delete

Record")

54
'If (answer = vbYes) Then
cmd.Connection = con

55
 cmd.CommandType = CommandType.StoredProcedure
cmd.CommandText = "spDeleteBuyerDetails1"
cmd.Parameters.Add("@Bno", SqlDbType.NVarChar).Value =
txtbuyerid.Text
'cmd.Parameters.AddWithValue("@ProductCode", ttProductCode.Text)
cmd.ExecuteNonQuery()
MsgBox("Details Deleted", vbInformation, "Successfully Deleted")
ClearGridView()
Load1()
Me.Refresh()
'Else
'

txtSerialNo.Focus()
'End If
Catch ex As Exception
MsgBox("Unable to Delete Record! Please Try Later", vbInformation,
"Error in Deleting")
End
Try
clear()
End Sub

Private Sub txtBSearch_KeyPress(ByVal sender As Object, ByVal e As

System.Windows.Forms.KeyPressEventArgs) Handles txtBSearch.KeyPress
Dim con As New
SqlConnection con = New

56
 SqlConnection()
con.ConnectionString = "Data Source=.\SQLEXPRESS;Initial
Catalog=Geeva;Integrated Security=True"
con.Open()

57
 Dim da As New SqlDataAdapter("spSearchBuyerDetails1", con)
da.SelectCommand.Parameters.Clear()
da.SelectCommand.CommandType = CommandType.StoredProcedure
da.SelectCommand.Parameters.AddWithValue("Bname", txtBSearch.Text)
Dim dt As New DataTable
da.Fill(dt)
DataGridView1.DataSource = dt
con.Close()
End Sub
Private Sub clear()
txtbuyerid.Clear()
txtBuyername.Clear()
txtcontact.Clear()
txtmail.Clear()
txtaddress.Clear()
'txtaccname.Clear()
'txtaccno.Clear()
'txtbankname.Clear()
'txtbranchname.Clear(
)
End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button1.Click
MDIParent1.Show()
Me.Hide()
End Sub
58
End Class

59
Imports System.Data
Imports System.Data.SqlClient
Public Class frmComplaints
Dim con As New SqlConnection
Dim cmd As New SqlCommand
Dim da As New SqlDataAdapter("select *from tblComplaint", con)
Dim ds As New DataSet
Dim dbind As New BindingSource
Dim a As Integer = 0
Private Sub frmComplaints_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
LoadDatabase()
Load1()
clear()
End Sub
Private Sub LoadDatabase()
con.Close()
con.ConnectionString = "Data Source=.\SQLEXPRESS;Initial
Catalog=Geeva;Integrated Security=True"
con.Open()
End Sub
Public Sub Load1()
ClearGridView()
LoadDatabase()
da.Fill(ds,
"tblcomplaint")

60
dbind.DataSource = ds

61
 dbind.DataMember =
ds.Tables(0).ToString()
DataGridView1.DataSource = dbind
End Sub

Private Sub ClearGridView()

For Each row As DataGridViewRow In
DataGridView1.Rows DataGridView1.Rows.Remove(row)
Next
End Sub

Private Sub btInsert_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btInsert.Click
LoadDatabase()
cmd.Parameters.Clear(
)
Try
cmd.Connection = con
cmd.CommandType = CommandType.StoredProcedure
cmd.CommandText = "spInsertComplaintDetails"
'cmd.Parameters.AddWithValue("@Bno", txtbuyerid.Text)
cmd.Parameters.AddWithValue("@Cuname", txtBuyername.Text)
cmd.Parameters.AddWithValue("@Pid", txtcontact.Text)
cmd.Parameters.AddWithValue("@Pname", txtmail.Text)
cmd.Parameters.AddWithValue("@Complaint", txtaddress.Text)
cmd.Parameters.AddWithValue("@Cdat", DateTimePicker1.Value)
'cmd.Parameters.AddWithValue("@Accname", txtaccname.Text)
'cmd.Parameters.AddWithValue("@Accno", txtaccno.Text)
62
'cmd.Parameters.AddWithValue("@Bankname", txtbankname.Text)
'cmd.Parameters.AddWithValue("@Branchname", txtbranchname.Text)

63
 cmd.ExecuteNonQuery()
MsgBox("Details of Complaint are Successfully Inserted", vbInformation,
"Successfully Inserted")
con.Close()
Catch ex As Exception
MsgBox("Details are not Inserted! Please Try Later", vbInformation, "Error
In Inserting Complaint Details")
End Try
ClearGridView()
Load1()
clear()
End Sub

Private Sub btUpdate_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btUpdate.Click
LoadDatabase()
Me.Refresh()
'Dim answer As
Long Try
cmd.Parameters.Clear()

'answer = MsgBox("Are you sure to Updating Data?", vbYesNo, "Updating

Record")
'If (answer = vbYes) Then
cmd.Connection = con
cmd.CommandType = CommandType.StoredProcedure
cmd.CommandText = "spUpdateComplaintDetails"
cmd.Parameters.AddWithValue("@Cuname", txtBuyername.Text)
64
 cmd.Parameters.AddWithValue("@Pid", txtcontact.Text)
cmd.Parameters.AddWithValue("@Pname", txtmail.Text)
cmd.Parameters.AddWithValue("@Complaint", txtaddress.Text)
cmd.Parameters.AddWithValue("@Cdat", DateTimePicker1.Value)
'cmd.Parameters.AddWithValue("@Accname", txtaccname.Text)
'cmd.Parameters.AddWithValue("@Accno", txtaccno.Text)
'cmd.Parameters.AddWithValue("@Bankname", txtbankname.Text)
'cmd.Parameters.AddWithValue("@Branchname", txtbranchname.Text)
cmd.Parameters.Add("@Cid", SqlDbType.NVarChar).Value =
txtbuyerid.Text
cmd.ExecuteNonQuery()
MsgBox("Complaint Details Updated", vbInformation, "Succesfully
Updated")
con.Close()
ClearGridView()
Load1()
Me.Refresh()
'Else
'txtSerialNo.Focus()
'End If
Catch ex As Exception

MsgBox("Unable to Update Record! Please Try Later", vbInformation,

"Error in Updating Record")
End
Try
clear()
End Sub
65
 Private Sub btDelete_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles btDelete.Click
LoadDatabase()
Me.Refresh()
' Dim answer As
Long Try
cmd.Parameters.Clear()

'answer = MsgBox("Are you sure to Deleting Data?", vbYesNo, "Delete

Record")
'If (answer = vbYes) Then
cmd.Connection = con
cmd.CommandType = CommandType.StoredProcedure
cmd.CommandText = "spDeleteComplaintDetails"
cmd.Parameters.Add("@Cid", SqlDbType.NVarChar).Value =
txtbuyerid.Text
'cmd.Parameters.AddWithValue("@ProductCode", ttProductCode.Text)
cmd.ExecuteNonQuery()
MsgBox("Details Deleted", vbInformation, "Successfully Deleted")
Load1()
Me.Refresh()
'Else
'

txtSerialNo.Focus()
'End If
Catch ex As Exception

MsgBox("Unable to Delete Record! Please Try Later", vbInformation,

66
"Error in Deleting")
End Try

67
 clear()
End Sub

Private Sub btClear_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btClear.Click
txtbuyerid.Clear()
txtBuyername.Clear()
txtcontact.Clear()
txtmail.Clear()
txtaddress.Clear()
End Sub
Private Sub clear()
txtbuyerid.Clear()
txtBuyername.Clear()
txtcontact.Clear()
txtmail.Clear()
txtaddress.Clear()
'txtaccname.Clear()
'txtaccno.Clear()
'txtbankname.Clear()
'txtbranchname.Clear(
)
End Sub

Private Sub DataGridView1_SelectionChanged(ByVal sender As Object, ByVal

e As System.EventArgs) Handles DataGridView1.SelectionChanged
Try

68
Dim dgv As DataGridView = TryCast(sender, DataGridView)

69
 If dgv IsNot Nothing AndAlso dgv.SelectedRows.Count > 0 Then
Dim row As DataGridViewRow = dgv.SelectedRows(0)
If row IsNot Nothing Then

txtbuyerid.Text = row.Cells(0).Value.ToString()
txtBuyername.Text = row.Cells(1).Value.ToString()
txtcontact.Text = row.Cells(2).Value.ToString()
txtmail.Text = row.Cells(3).Value.ToString()
txtaddress.Text = row.Cells(4).Value.ToString()
'txtaccname.Text = row.Cells(5).Value.ToString()
'txtaccno.Text = row.Cells(6).Value.ToString()
'txtbankname.Text = row.Cells(7).Value.ToString()
'txtbranchname.Text =
row.Cells(8).Value.ToString()

End If
End If
Catch ex As Exception
End Try
End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button1.Click
MDIParent1.Show()
Me.Hide()
End Sub
End Class

70