A

PROJECT REPORT

On

“College ERP”
of

Submitted in partial fulfillment of their requirements for the

award of the B-Tech in

Computer Science and Engineering

Under the supervision of

Er. Ankit Diwedi

(Project Manager)

Varcas Software Solution (P) Ltd.

Lucknow (UP)

Submitted By:-

Student Name : Lucky

Submitted To:-

College Name : Babu Sunder Singh Institute of Technology

& Management , Lucknow

1
 PREFACE
“ Necessity is Mother of All Inventions ”

Summer training is an important part of the engineering curriculum. The B.Tech

course summer training helps a student in getting acquainted with the manner in

which his/her knowledge is being practically used outside his/her institute and this

is normally different from what he/she has learnt from books. Hence, when the

student switches from the process of learning to that of implementing his/her

knowledge, he/she finds an abrupt change. This is exactly why summer training

session during the B.E curriculum becomes all the more important. Summer training

is prescribed for the student of Technical College as a part of the four-year degree

course of engineering by the AICET. We are required to undergo summer training

for a period of 45 days after the completion of the 4th year.

This training report describes in detail the training after the 4th year session, which I

completed at the Varcas Software Solution. . This report also gives the information

about the organization and it’s working along with the project undertaken in the

training period.

The fundamental step used in SDLC process is based on the ISO 9001 guidelines. My

aim was to follow the ISO guidelines and develop a perfect system.

The system development was organized into 5 major parts:

1. Requirement Gathering

2. Documentation/Design

3. Development

4. Coding

2
5. Testing

3
 ACKNOWLEDGEMENT

I would like to express my deep and sincere gratitude to my supervisor Er. Ankit

Diwedi , Project Manager (Varcas Software Solution(P) Ltd.), who gave me his full

support and encouraged me to work in an innovative and challenging project for

Educational field. His wide knowledge and logical thinking gave me right direction

all the time.

I am deeply grateful my project coordinator for his/her help and support provided at

every step of the project. Last but not the least, I thank to all employees of Varcas

Software Solution (P) Ltd. for their support and co-operation.

Student Name
Lucky Mishra

4
 Varcas
PVT.LTD.

COMPLETION CERTIFICATE

This is to certify that Mr. /Ms. Rahul Sharma of B.Tech (Computer Science and

Engineering ) from College Name (Babu Sunder Singh Institute of Technology &

Management , Lucknow) was working on the project entitled “College ERp” in

Varcas Software Solution Pvt. Ltd.

He has done an excellent job during her engagement with the Software

Development & Testing Division of the company. He has completed his/her project

during the training tenure. Her performance has been good and satisfactory.

I would like to take this opportunity to express my appreciation to Mr. Lucky

Mishra for Her work and wish her all the very best for her future endeavors.

Regards,

Varcas Software Solution (P) Ltd.

Lucknow (U.P.)

DECLARATION

5
This is to certify that the project report entitled “www.collegeerp.varcas,org” is done

by me is an authentic work carried out for the partial fulfillment of the requirements

for the award of the B.Tech in “(Computer Science and Engineering)” under the

guidance of Er. Ankit Diwedi . The matter embodied in this project work has not

been submitted earlier for award of any degree to the best of my knowledge and

belief.

Student Name
Lucky Mishra

INDEX

6
1. Introduction………………………………………………………………………

1.1 Overview of Organization

1.2 Objectives

1.3 Existing System Description

1.4 Proposed System

1.5 Tools Used

2. System Analysis…………………………………………………………………

2.1 Objective

2.2 SDLC Phases

2.2.1 Feasibility Study

2.2.2 Report Approval

2.2.3 System Analysis

2.2.4 System Design

2.2.5 Coding

2.2.6 Testing

2.2.7 Implementation

2.2.8 Maintenance

2.3 Process Description

2.4 Project Model Used

2.5 ER-Diagram

2.6 Data Flow Diagram

3. Software Requirement Specification………….………………………………

3.1 Hardware Requirement

3.2 Software Requirement

3.3 Support Maintenance

4. System Design

Approach…………………………………………………………
4.1 Top-Down Designing

4.2 Bottom –Up Designing

7
 4.3 Following Approach

5. Low Level Design…………………………………………………………………………

5.1 Description of Classes and Methods

6. Data Modeling……………………………………………………………………

6.1 List of Tables

6.2 Structure of Tables

7. Testing………………………………………………………………………………

8. Input-Output Forms………………………………………………………………

8.1 Modularization Details

8.2 User Screenshots

8.3 Admin Screenshots

9. Future Scope………………………………………………………………………

10. Conclusion……………………………………………………………………….

8
 INTRODUCTION OF THE CLIENT
College ERP is an ERP brand that runs chains of Teacher student college

and convenience stores. The brand is wholly owned by Future Navayal College ERP.

Future Group, that owns and operate Big Bazaar, combined retail operations with

CollegeERp. The merger has created one of India's biggest retail chains with more

than 890 stores in 246 cities in India.

OVERVIEW OF ORGANIZATION

Varcas Software Solution (P) Ltd is a software consulting firm provides a full-range

of software solution, web design and development services for start-up to well-

established companies.

Technologies are transcending boundaries and their volatility is putting stringent

demands on the time and mind-space of techno-professionals. At SPG, we update

ourselves with technologies even before they become norms and master them long

before they become redundant. That's why we are on the roster of clients from across

the continents. Come to think of it, we have engineered ourselves to be at the very

forefront in Web based technology. Our core competencies span a spectrum of web-

intensive services that range from website designing to robust backend

management.

OBJECTIVES
An aim of a business is the purpose of the business. The aims are what Marks and
Spencer is trying to achieve in the long term. All business has different aims and
Objectives that vary in some kind. For an Example Marks and Spencer aim might be
to make sure that they make a profit this year. The meaning of SMART objectives is

9
that the objectives that they set for the company should include being Specific,
Measurable, Agreed, Realistic, and Time Specific.

1. Specific: Specific is being specific and stating what the company is aiming to

achieve.

2. Measurable: Measurable is setting Objectives that believe that can be measured so

that they can decide whether the objective has been achieved.

3. Agreed: When sets their objectives, they must make sure that they get everyone

involve within the decision making. The staff must also understand the objectives

that the company is setting and the company as whole must agree.

4. Realistic: Marks and Spencer must set realistic objectives that are based on its

competitors and the resources and the market.

5. Time specific: Marks and Spencer should state and Specific time in which they

wish to have achieved these objectives by so they know what they have to work

towards in order to meet that time.

10
 PROBLEM DEFINITION

In this section we shall discuss the limitation and drawback of the existing system

that forced us to take up this project. Really that work was very typical to manage

the daily errors free records and adding or removing any node from server. This

problem produces a need to change the existing system. Some of these shortcomings

are being discussed below: -

● Low Functionality

With the existing system, the biggest problem was the low functionality. The

problem faced hampered the work. For small task like adding any new node to

server or deleting a node or keeping daily record we have to appoint minimum two

or three employee.

● Erroneous Input and Output

In the existing system, humans performed all the tasks. As in the human tendency,

error is also a possibility. Therefore, the inputs entered by the person who is

working in the Company, in the registers may not be absolutely foolproof and may

be erroneous. As a result of wrong input, the output reports etc. Will also be wrong

which would in turn affect the performance.

● Portability Problem

System that existed previously was manual. As a result, the system was less

portable. One has to carry the loads of many registers to take the data from one place

to another. A big problem was that the system was less flexible and if we wanted to

calculate yearly or monthly maintenance report or efficiency report, then it was a big

headache.

11
 ● Security-

Security concerns were also one of the motives of the Company for the need of

software. In the registers, the data is not secure as anybody can tamper with the data

written in the registers. While in this software, just a password makes it absolutely

secure from the reach of unauthorized persons.

● Data Redundancy

In the case of manual system, the registers are maintained in which, a lot of data is

written.

● Processing Speed

In manual system maintaining a register and performing the necessary calculation

has proved to be a troublesome job, which takes a lot of time and may affect the

performance of the Company. But with this software we can have all the tasks

performed in a fraction of second by a single click thus making the troublesome job

much easier.

● Manual Errors

When a number of tough tasks are prepared by the humans like preparation of

reports, performing long calculation then some human error are obvious due to a

number of factors like mental strain, tiredness etc. But as we all know that computer

never get tired irrespective of the amount of work it has to do. So this software can

nullify the probability of manual error that improve the performance.

● Complexity in Work

12
In manual system whenever a record is to be updated or to be deleted a lot of cutting

and overwriting needs to be done on the registers that are concerned that are deleted

or updated record, which makes the work very complex.

EXISTING SYSTEM DESCRIPTION

The existing system Easy Day Online is to manage the relationship with

User members by storing the user data in registers. The existing system has

following drawbacks:

● Time Consuming

● Manual Errors

● Complexity

● Low Security

● Data Redundancy

● Portability

● No more helpful to improve business.

PROPOSED SYSTEM

The aim of proposed system is to develop a system of improved facilities. The

proposed system can overcome all the limitations of the existing system. The System

provides proper security and reduces the manual work.

13
 We proposed complete website solution for the application to create a “User

Relationship Management” website. The iterative, time bound approach adopted by

Softpro to address the client requirements that are as follows:

1. Define To- Be processes

i. Come up with the solution of the existing problem

ii. Go through the regressive reviews by different business process

iii. Prepared user interface requirements

2. Develop High Level Design and Low Level Design before Execution

i. Built and design all the processes required by Client

ii. Conducted survey of all Courier services Dealing Websites and

documented realities

iii. Developed the architecture of the Software Solution

iv. Developed the project design in detail for the software developer in

company

14
 SYSTEM ANALYSIS

OBJECTIVE:

An aim of a business is the purpose of the business. The aims are what Marks

and Spencer is trying to achieve in the long term. All business has different aims

and Objectives that vary in some kind. For an Example Marks and Spencer aim

might be to make sure that they make a profit this year. The meaning of SMART

objectives is that the objectives that they set for the company should include

being Specific, Measurable, Agreed, Realistic, and Time Specific.

1. Provides the searching facility based on various type of product to

customers.

2. Online shopping system also manages the various type of product to

customer.

3. It tracks all the information of various types of products to the end

customers.

4. Manages the information of customers.

15
 5. Shows the information and description of the various types of products to

customer.

6. To increase efficiency of managing the e-commerce platform.

7. It deals with monitoring the information and transaction of payments.

8. Adding, Editing, and updating of records is improved which results in

proper resource management of online shopping system data.

Phases:
System Development Life Cycle (SDLC) mainly consists of the following 7 phases

which can be detailed:-

Preliminary Investigation: -
This is the first phase of the system development life cycle. In this phase we tend

to find out the needs of the client –what exactly does the client want? Before the

development of any system the important point is to know the needs, objectives

and scope of the system.

Feasibility Study: -
Feasibility study is the second step of the system development life cycle. Things are

always easy at the beginning in any software process. In fact nothing is in feasible

with unlimited time and resources. But it is not the fact. So, practically we have to do

in limited resources in a restricted time margin. So for the system to be feasible,

following points we have to consider.

The feasibility study is conducted to check whether the candidate system is

feasible. The system which is selected to be the best against the criteria is there after

16
designed and developed. The feasibility study takes in to consideration, the risks

involved in the project development beforehand. Therefore in this phase we have to

do feasibility study which is the test of the website according to its work ability,

impact on the organization, ability to meet user need and effective use of resources.

We do the feasibility study for website to analyze the risks, costs and benefits

relating to economics, technology and user organization. There are several types of

feasibility depending on the aspect they cover. Import of these includes:

Technical Feasibility:
This is an important outcome of preliminary investigation. It comprise of

following questions:-

● Can the work of projected one with the current equipment, existing software and

available man power resource?

● If Technology is required what are the possibilities that it can be

developed?

Economic Feasibility:
It deals with question related to the economy. It comprise of the following

questions:-

● Are there sufficient benefits in creating the system to make the cost acceptable?

● Are the costs of not creating the system so great that the project must be undertaken?

Legal Feasibility:
It deals with the question related to the legal issues. It comprise of the following

questions:-

17
● Contract Signing

● Software License agreement

● Issues related to cyber laws.

● Legal issues relating to the man power contract.

Operational Feasibility:
The operational feasibility consists of the following activity:-

● Will the system be useful if it is developed &implemented?

● Will there be resistance from employee?

Social & Behavioral Feasibility:

It deals with the various issues related to the human behavior like:-

● Whether the user be able to adapt a new change or not?

● Whether the ambiance we are providing suits the user or not?

Request Approval:-
Request approval is the third phase of system development lifecycle. Request

approval is the phase in which all the requirements which would be provide in the

system are stated. The request approval is a sort of agreement between the client and

the company which is building this software. Both the parties should be mutually

agreed on the stated requirements.

System Analysis:-
18
System analysis is the phase following the phase of the request approval. In this

phase we tend to analyze the overall system which we have to build. System

analysis is the crucial part in SDLC.

System Design:-
System design means the designing of the system. The System can be done in either

of the following two ways:-

● Logical System Design

● Physical System Design

Coding:-

Coding is the phase in which a developer codes using any programming languages.

Coding constitutes only20 % of the whole project and which is easier to write.

The coding work is also done in the teams; development of the system is usually

done under the modular programming style, which can be either top-down

approach or bottom-up approach.

Testing:-

Testing is the phase in which the system that has been developed is tested. Testing

comprises of the 60%ofthe overall development of the system. Testing of the system

is important because testing aims to uncover the different errors in the system.

There are various different testing techniques that can be used for the testing of the

system.

Implementation:-

Implementation process involved the installation of software on user’s side.

Implementation process actually depends on type of a system &various. Opting for

suitable conversion approach is a step implementation. The conversion processes

19
are as follows:-

● Parallel Conversion

● Direct Conversion Approach

● Pilot Conversion Approach

● Phase In Conversion Approach

20
Maintenance: -

Merely developing the system is not important but also maintenance is important.

The company that has built the system provides for some time free of cost

maintenance to the client and after that period it is usually a paid service.

21
Process Description

Gantt charts mainly used to allocate resources to activities. The resources allocated to

activities include staff, hardware, and software. Gantt charts (named after its

developer Henry Gantt) are useful for resource planning. A Gantt chart is special

type of bar chart where each bar represents an activity. The bars are drawn along a

timeline. The length of each bar is proportional to the duration of the time planned

for the corresponding activity.

Gantt chart is a project scheduling technique. Progress can be represented easily in a

Gantt chart, by coloring each milestone when completed. The project will start in the

month of January and end after 4 months at the beginning of April.

PROJECT MODEL USED

Iterative Enhancement Model

⮚ This model has the same phases as the waterfall model, but with fewer

restrictions.

⮚ Generally the phases occur in the same order as in the waterfall model, but

they may be conducted in several cycles.

⮚ Useable product is released at the end of the each cycle, with each release

providing additional functionality. Customers and developers specify as many

requirements as possible and prepare a SRS document. Developers and customers

then prioritize these requirements. Developers implement the specified requirements

22
in one or more cycles of design, implementation and test based on the defined

priorities.

The procedure itself consists of the initialization step, the iteration step, and the

Project Control List. The initialization step creates a base version of the system. The

goal for this initial implementation is to create a product to which the user can react.

It should offer a sampling of the key aspects of the problem and provide a solution

that is simple enough to understand and implement easily. To guide the iteration

process, a project control list is created that contains a record of all tasks that need to

be performed. It includes such items as new features to be implemented and areas of

redesign of the existing solution. The control list is constantly being revised as a

result of the analysis phase.

The iteration involves the redesign and implementation of iteration is to be simple,

straightforward, and modular, supporting redesign at that stage or as a task added

to the project control list. The level of design detail is not dictated by the iterative

approach. In a light-weight iterative project the code may represent the major source

of documentation of the system; however, in a critical iterative project a

formal Software Design Document may be used. The analysis of an iteration is based

upon user feedback, and the program analysis facilities available. It involves analysis

of the structure, modularity, usability, reliability, efficiency, & achievement of goals.

The project control list is modified in light of the analysis results.

PHASES:
Incremental development slices the system functionality into increments (portions).

In each increment, a slice of functionality is delivered through cross-discipline work,

from the requirements to the deployment. The unified process groups

23
increments/iterations into phases: inception, elaboration, construction, and

transition.

● Inception identifies project scope, requirements (functional and non-functional)

and risks at a high level but in enough detail that work can be estimated.

● Elaboration delivers a working architecture that mitigates the top risks and

fulfills the non-functional requirements.

● Construction incrementally fills-in the architecture with production-ready code

produced from analysis, design, implementation, and testing of the functional

requirements.

● Transition delivers the system into the production operating environment.

24
ER-Diagram

Introduction:-

In software engineering, anentity-relationship model (ERM) is an abstract and

conceptual representation of data. Entity-relationship modeling is a database

modeling method, used to produce a type of conceptual schemaor semantic data

model of a system, often a relational database, and its requirements in a top-down

fashion. Diagrams created by this process are called entity-relationship diagrams, ER

diagrams, or ERDs. ER Diagrams depicts relationship between data objects. The

attribute of each data objects noted in the entity-relationship diagram can be

described using a data object description. Entity relationship diagram is very basic,

conceptual model of data and it is fundamental to the physical database design. This

analysis is then used to organize data as relations, normalizing relations, and

obtaining a Relational database.

The entity-relationship model for data uses three features to describe data. These are:

1. Entities which specify distinct real-world items in an application.

2. Relationship, which connect entities and represent meaningful dependencies

between them.

3. Attributes which specify properties of entities & relationships.

25
E-R Diagram

26
Data Flow Diagram

Introduction:-
DFD is an acronym for the word Data Flow Diagram. DFD is ppictorial

representation of the system. DFD is a graphical representation of the ―flow of data

through the information system. DFD are also used for the visualization of data

processing (structured design). ADFD provides no information about the timings of

the process, or about whether process will operate in parallel or sequence. DFD is an

important technique for modeling a system’s high-level detail by showing how input

data is transformed to output results through sequence of functional

transformations. DFD reveal relationships among between the various components

in a program or system. The strength of DFD lies in the fact that using few symbols

we are able to express program design in an easier manner. A DFD can be used to

represent the following:-

External Entity sending and receiving data.

Process that change the data.

Flow of data within the system.

Data Storage locations.

Uses of DFD:-

The main uses of data flow diagrams are as follows:-

DFD is a method of choice for representation of showing of information through a

system because of the following reasons:-

27
 ● DFDs are easier to understand by technical and non-technical audiences.

● DFDs can provide high level system overview, complete with boundaries and

connections to other system.

● DFDs can provide a detailed representation of system components.

0 Level DFD

USER
Login Loginn
SmileONN
Online ADMIN
Accept/Reject MEDICOUNSEL
Accept/Reject
Confirm Registration

Change Password Change Password

28
 1 Level DFD

USER Admin
2.0
Admin 2.2
Customer Works Add Products
3.0 Registration

4.0 Customer
works 2.3
Add Category
4.2 Add to cart

4.1 2.4
View Products View All
Customers
4.3 Change
password

4.4 Place
Order
2.5
Change
Password

4.5 Update Profile

SOFTWARE REQUIREMENT SPECIFICATION

A requirements specification for a software system is a complete description of the

behavior of a system to be developed and it includes a set of use cases that describe

29
all the interactions the users will have with the software. In addition to use cases, the

SRS also contains non-functional requirements.

Non-functional requirements are requirements which impose constraints on the

design or implementation (such as performance engineering requirements, quality

standards, or design constraints).Requirements are a sub-field of software

engineering that deals with the elicitation, analysis, specification, and validation of

requirements for software.

The software requirement specification document enlists all necessary requirements

for project development. To derive the requirements we need to have clear and

thorough understanding of the products to be developed. This is prepared after

detailed communications with project team and the customer.

Hardware Requirements

1. Minimum 350MB Hard Disk space for installation

2. 4GB HD space required for a typical live system with 1000-2000 events

3. Recommended minimum CPU - Pentium 4, 3.2GHz

4. Recommended 4GB RAM for a Central Server with 3 Nodes

5. Network card

Software Requirements

1. Client on Internet: Web Browser, Operating System (any).

2. Client on Intranet: Client Software, Web Browser, Operating System (any).

3. Visual Studio 2015

30
 4. MS SQL Server 2012

5. Notepad++ or any test editor

SUPPORT AND MAINTENANCE:-

One year free support for rectifying system bugs including front end and beck end

will be provided. During warranty period Software Engineers will be responsible for

removing bugs and improving it. After one year support can be extended @ 20% of

the total product deployment cost.

SYSTEM DESIGN APPROACH

Top – Down designing:

The top - down designing approach started with major components of the system. It

is a stepwise refinement which starts from an abstract design, in each steps the

design is refined two or more concrete levels until we reach a level where no – more

refinement is possible or not needed.

31
Bottom – Up designing:

In bottom – up designing the most basic and primitive components are designed

first, and we proceed to higher level components. We work with layers of

abstractions and abstraction are implemented until the stage is reached where the

operations supported by the layer is complete.

Approach we are following:

In this project we are following Mixed Approach i.e. a combination of top – down

and bottom – up. We are developing some of the components using top – down

designing approach (e.g. the Web Pages) and the some components in bottom – up

designing approach (e.g. the middle tier classes).

DATA MODELING

LIST OF TABLES:

✔ tbl_login

✔ tbl_Course

✔ tbl_Branch

32
✔ tb_Semester

✔ tbl_Exam

✔ Tbl_contact

✔ Tbl_feedback

✔ tbl_Collete

✔ tbl_Attendance

✔ tbl_Enquiry

A) Tbl_admin

33
B) tbl_answer

C) Tbl_buy

34
D) Tbl_cart

E) Tbl_category

35
F) Tbl_contact

G) Tbl_feedback

H) Tbl_feedback

36
 I) Tbl_product

Low Level Design

Description: Low Level Design creation is one of the most important activities in the

development of any software product. The low level design document gives the

design of the actual software application. Low level design document is based on

High Level Design document. It defines internal logic of every sub module. A good

low level design document will make the application very easy to develop by the

37
developer. An effective design document results in very low efforts in developing a

Software product.

Each project's low level design document should provide a complete and

detailed specification of the design for the software that will be developed in the

project, including the classes, member and non-member functions, and associations

between classes that are involved.

The low level design document should contain a listing of the declarations

of all the classes, non-member-functions, and class member functions that will be

defined during the subsequent implementation stage, along with the associations

between those classes and any other details of those classes (such as member

variables) that are firmly determined by the low level design stage. The low level

design document should also describe the classes, function signatures, associations,

and any other appropriate details, which will be involved in testing and evaluating

the project according to the evaluation plan defined in the project's requirements

document.

TESTING:

Testing is the integral part of any System Development Life Cycle insufficient and

interested application tends to crash and result in loss of economic and manpower

investment besides user’s dissatisfaction and downfall of reputation.

“Software Testing can be looked upon as one among much process, an

organization performs, and that provides the last opportunity to correct any flaws in

the developed system. Software Testing includes selecting test data that have more

probability of giving errors.” The first step in System testing is to develop the plan

that all aspect of system .Complements, Correctness, Reliability and Maintainability.

38
 Software is to be tested for the best quality assurance, an assurance that

system meets the specification and requirement for its intended use and

performance.

System Testing is the most useful practical process of executing the program

with the implicit intention of finding errors that makes the program fail.

Types of Testing:

Black Box (Functional) Testing:

Testing against specification of system or components. Study it by examining its

inputs and related outputs. Key is to devise inputs that have a higher likelihood of

causing outputs that reveal the presence of defects. Use experience and knowledge

of domain to identify such test cases. Failing this a systematic approach may be

necessary. Equivalence partitioning is where the input to a program falls into a

number of classes, e.g. positive numbers vs. negative numbers. Programs normally

behave the same way for each member of a class. Partitions exist for both input and

output. Partitions may be discrete or overlap. Invalid data (i.e. outside the normal

partitions) is one or more partitions that should be tested.

Internal System design is not considered in this type of testing. Tests are based on

requirements and functionality.

This type of test case design method focuses on the functional requirements of the

software, ignoring the control structure of the program. Black box testing attempts to

find errors in the following categories:

● Incorrect or missing functions.

● Interface errors.

● Errors in data structures or external database access.

39
 ● Performance errors.

● Initialization and termination errors.

White Box (Structural) Testing:

Testing based on knowledge of structure of component (e.g. by looking at source

code). Advantage is that structure of code can be used to find out how many test

case need to be performed. Knowledge of the algorithm (examination of the code)

can be used to identify the equivalence partitions. Path testing is where the tester

aims to exercise every independent execution path through the component. All

conditional statements tested for both true and false cases. If a unit has no control

statements, there will be up to 2n possible paths through it. This demonstrates that it

is much easier to test small program units than large ones. Flow graphs are a

pictorial representation of the paths of control through a program (ignoring

assignments, procedure calls and I/O statements). Use flow graph to design test

cases that execute each path. Static tools may be used to make this easier in

programs that have a complex branching structure. Tools support. Dynamic

program analyzers instrument a program with additional code. Typically this will

count how many times each statement is executed. At end print out report showing

which statements have and have not been executed. Problems with flow graph

derived testing:

40
 ● Data complexity could not take into account.

● We cannot test all paths in combination.

● In really only possible at unit and module testing stages because beyond that

complexity is too high.

This testing is based on knowledge of the internal logic of an application’s code. Also

known as a Glass Box Testing .Internal software and code working should be known

for this type of testing. Tests are based on coverage of code statements, branches,

paths, conditions.

Unit Testing:

Unit testing concentrates on each unit of the software as implemented in the code.

This is done to check syntax and logical errors in programs. At this stage, the test

focuses on each module individually, assuring that it functions properly as a unit. In

our case, we used extensive white-box testing at the unit testing stage.

A developer and his team typically do the unit testing do the unit testing is done in

parallel with coding; it includes testing each function and procedure.

Incremental Integration Testing:

Bottom up approach for testing i.e. continuous testing of an application as new

functionality is added; Application functionality and modules should be

independent enough to test separately done by programmers or by testers.

41
Integration Testing:

Testing of integration modules to verify combined functionality after

integration .Modules are typically code modules, individual applications, client and

server and distributed systems.

Functional Testing:

This type of testing ignores the internal parts and focus on the output is as per

requirement or not .Black box type testing geared to functionality requirements of an

application.

System Testing:

Entire system is tested as per the requirements. Black box type test that is based on

overall requirement specifications covers all combined parts of a system.

End-to-End Testing:

Similar to system testing ,involves testing of a complete application environment in a

situation that mimics real-world use, such as interacting with a database ,using

network communications, or interacting with hardware, applications, or system if

appropriate.

Regression Testing:

Testing the application as a whole for the modification in any module or

functionality. Difficult to cover all the system in regression testing so typically

automation tools are used for these testing types.

42
Acceptance Testing:

Normally this type of testing is done to verify if system meets the customer specified

requirements. User or customers do this testing to determine whether to accept

application.

Performance Testing:

Term often used interchangeably with “stress” and “load” testing, To check whether

system meets performance requirements, Used different performance and load tools

to do this.

Alpha Testing:

In house virtual user environment can be created for this type of testing. Testing is

done at the end of development .Still minor design changes may be made as a result

of such testing.

Beta Testing:

Testing typically done by end-users or others. This is final testing before releasing

application for commercial purpose.

43
SNAPSHOTS

44
 Index

Signup and Signin

Dashboard

45
 Course Master

Fee Management

46
Section

47
 Seating Plan

Leave Management

Library Mangement

48
Payroll mangement

Opening Drive

49
Time Table Mangement

50
 AcademyController

using AutoMapper;
using ERP.Data.Models;
using ERP.Dto;
using ERP.Dto.AcademicMaster;
using ERP.Dto.Common_Model;
using ERP.Services;
using ERP.Web.Controllers;
using ERP.Dto.Academic;
using ERP.Services;
using ERP.Services.Academic;
using ERP.Web.Controllers;
using Microsoft.AspNetCore.Mvc;
using ERP.Services.Extensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace ERP.Web.Areas.Admin.Controllers
{
[Area("Admin")]

public class AcademicController : BaseController

{

private readonly IMapper _mapper;

private readonly ICourseMasterService _courseMasterService;
private readonly IAcademicSessionService _academicSessionService;
private readonly ISubjectCategoryService _subjectCategoryService;
private readonly ICreateSubjectService _createSubjectService;
private readonly ISubjectCourseMappingService _subjectCourseMappingService;
private readonly IAcademicService _academicService;
private readonly IDropdownHelper _dropdownHelper;
public AcademicController(ICourseMasterService courseMasterService,
IAcademicSessionService academicSessionService, ISubjectCategoryService subjectCategoryService,
ICreateSubjectService createSubjectService, ISubjectCourseMappingService
subjectCourseMappingService, IAcademicService academicservice, IMapper mapper,
IDropdownHelper dropdownHelper)
{
_academicService = academicservice;
_courseMasterService = courseMasterService;
_academicSessionService = academicSessionService;
_subjectCategoryService = subjectCategoryService;
_createSubjectService = createSubjectService;
_subjectCourseMappingService = subjectCourseMappingService;
_mapper = mapper;
_dropdownHelper = dropdownHelper;
}

51
 [HttpGet]

public IActionResult CourseMaster()

{

return View();
}

[HttpGet]
public IActionResult SpecialisationMaster(int id)
{
SpecializationDto model = new SpecializationDto();
var SpecialisationMaster = _academicService.GetSpecialisationMasterList();
try
{

var qualification = _academicService.GetById(id);

if (qualification != null)
{

model = _mapper.Map<SpecializationDto>(qualification);
}
}
catch { }
model.LstSpecialization =
_mapper.Map<IReadOnlyList<SpecializationDto>>(SpecialisationMaster);

return View(model);
}

[HttpPost]
public async Task<IActionResult> SpecialisationMaster(SpecializationDto model)
{
try
{
var msg = "";
if (ModelState.IsValid)
{
bool ifExists = _academicService.Exists(model.SpecializationName);

Specialisation academic = _mapper.Map<Specialisation>(model);

academic.IsActive = true;
academic.EntryDate = DateTime.Now;
academic.Entryby = CurrentUser.UserID;
academic.CollageId = CurrentUser.CollegeId;

if (ifExists == true && model.SpecialisationId > 0)

{

52
 var isUpdate = academic.SpecialisationId != 0;
_academicService.Update(academic);
msg = $" Data Update Successfully";
}
else if (ifExists == false && model.SpecialisationId == 0)
{
_academicService.Save(academic);
msg = $" Data Save Successfully";
}
else
{
msg = $"Enter Specialisation name allready exits please try diffrent name";
}

ShowSuccessMessage("Success", msg, false);

}
return RedirectToAction("SpecialisationMaster");

}
catch (Exception ex)
{
ShowErrorMessage("Error", "Something went wrong. Please try again or contact support.");

// Return to the view with the original model.

return View(model);
}
}
public IActionResult DeleteSpecialisationMaster(int id)
{
try
{
if (id == 0)
{

ShowErrorMessage("Error", "Branch is empty");

}
else
{
_academicService.Delete(id);

ShowSuccessMessage("Success", "Delete Data Successfully", false);

}
return RedirectToAction("SpecialisationMaster");
}
catch (Exception ex)
{

ShowErrorMessage("Error", "Something went wrong");

return RedirectToAction("SpecialisationMaster");
}

53
 }

[HttpGet]
public async Task<IActionResult> CourseMapping(int MappingId)
{
var courseSpecialisationMappingDto= new CourseSpecialisationMappingDto();
ViewBag.courses = await _academicService.GetAllCourses();
ViewBag.branch = await _academicService.GetAllBranches();

var feeHeadMasters =
_academicService.GetCourseSpecialisationMappingList();

try
{
var courseSpecialisationMapping =
_academicService.GetBymappingId(MappingId);
if (courseSpecialisationMapping != null)
{

courseSpecialisationMappingDto =
_mapper.Map<CourseSpecialisationMappingDto>(courseSpecialisationMapping);

courseSpecialisationMappingDto.courseSpecialisationMappings =
_mapper.Map<IReadOnlyList<CourseSpecialisationMappingDto>>(feeHeadMasters);
}
else
{

courseSpecialisationMappingDto.courseSpecialisationMappings =
_mapper.Map<IReadOnlyList<CourseSpecialisationMappingDto>>(feeHeadMasters);
}
}
catch { }

return View(courseSpecialisationMappingDto);
}

[HttpPost]
public IActionResult CourseMapping(CourseSpecialisationMappingDto model)
{
try
{
if (model == null) return BadRequest("Invalid model");

CourseSpecialisationMapping courseSpeMapping =
_mapper.Map<CourseSpecialisationMapping>(model);
courseSpeMapping.CollageId = CurrentUser.CollegeId;

if (courseSpeMapping.MappingId != 0)
{
_academicService.Update(courseSpeMapping);

54
 ShowSuccessMessage("Success", "Data Updated Successfully", false);
}
else
{
_academicService.Save(courseSpeMapping);
ShowSuccessMessage("Success", "Data Saved Successfully", false);
}

return RedirectToAction("CourseMapping");
}
catch (Exception ex)
{
ShowErrorMessage("Error", "Something went wrong");
return View();
}
}

public IActionResult AcdemicSession()

{
return View();
}
[HttpGet]
public IActionResult SubjectCategory(int? id)
{
var subjectCategoryDto = new SubjectCategoryDto();

var subjectCategories = _subjectCategoryService.GetSubjectCategoryList();

try
{
var subjectCategory = _subjectCategoryService.GetById(Convert.ToInt32(id));
if (subjectCategory != null)
{

subjectCategoryDto = _mapper.Map<SubjectCategoryDto>(subjectCategory);
subjectCategoryDto.subjectCategories =
_mapper.Map<IReadOnlyList<SubjectCategoryDto>>(subjectCategories);
}
else
{
subjectCategoryDto.subjectCategories =
_mapper.Map<IReadOnlyList<SubjectCategoryDto>>(subjectCategories);
}
}
catch { }
return View(subjectCategoryDto);
}
[HttpPost]
public IActionResult SubjectCategory(SubjectCategoryDto model)

55
 {
try
{
if (!_subjectCategoryService.Exists(model.SubjectCategoryName))
{

if (model == null) return BadRequest("Invalid model");

var subjectCategory = _mapper.Map<SubjectCategory>(model);

subjectCategory.IsActive = true;
subjectCategory.EntryDate = DateTime.Now;
subjectCategory.Entryby = CurrentUser.UserID;
subjectCategory.CollageId = CurrentUser.CollegeId;

var isUpdate = subjectCategory.SubjectCategoryId != 0;

(isUpdate ? _subjectCategoryService.Update :
(Action<SubjectCategory>)_subjectCategoryService.Save)(subjectCategory);

ShowSuccessMessage("Success", isUpdate ? "Data Updated Successfully" : "Data Saved

Successfully", false);
}
else
{
var msg = $"Enter Subject Category name allready exits please try diffrent name";
ShowSuccessMessage("Success", msg, false);
}
return RedirectToAction("SubjectCategory");
}
catch (Exception ex)
{

ShowErrorMessage("Error", "Something went wrong");

return View();
}

public IActionResult DeleteSubjectCategory(int id)

{
try
{
if (id == 0)
{

ShowErrorMessage("Error", "id is empty");

56
 else
{
_subjectCategoryService.Delete(id);

ShowSuccessMessage("Success", "Delete Data Successfully", false);

}
return RedirectToAction("SubjectCategory");
}
catch (Exception ex)
{

ShowErrorMessage("Error", "Something went wrong");

return RedirectToAction("SubjectCategory");
}
}
[HttpGet]
public async Task<IActionResult> CreateSubject(int id)
{
var createSubjectDto = new CreateSubjectDto();
ViewBag.subjectCategory = await _dropdownHelper.GetAllSubjectCategory();
var subjectList = _createSubjectService.GetCategoryList();
createSubjectDto.LstSubject = _mapper.Map<IReadOnlyList<CreateSubjectDto>>(subjectList);

try
{
var createSubject = _createSubjectService.GetById(Convert.ToInt32(id));
if (createSubject != null)
{

createSubjectDto = _mapper.Map<CreateSubjectDto>(createSubject);
}
}
catch { }
return View(createSubjectDto);

[HttpPost]
public async Task<IActionResult> CreateSubject(CreateSubjectDto model)
{
try
{
ViewBag.subjectCategory = await _dropdownHelper.GetAllSubjectCategory();

if (!_createSubjectService.Exists(model.SubjectName))
{
if (model == null) return BadRequest("Invalid model");

var subject = _mapper.Map<Subject>(model);

subject.CollageId = CurrentUser.CollegeId;
subject.IsActive = true;

57
 subject.EntryDate = DateTime.Now;
subject.Entryby = CurrentUser.UserID;

var isUpdate = subject.SubjectId != 0;

(isUpdate ? _createSubjectService.Update : (Action<Subject>)_createSubjectService.Save)

(subject);

ShowSuccessMessage("Success", isUpdate ? "Data Updated Successfully" : "Data Saved

Successfully", false);
}
else
{
var msg = $"Enter Subject name allready exits please try diffrent name";
ShowSuccessMessage("Success", msg, false);
}
return RedirectToAction("CreateSubject");
}
catch (Exception ex)
{

ShowErrorMessage("Error", "Something went wrong");

return View();
}
}

[HttpGet]
public async Task<IActionResult> SubjectCoureseMapping(int id)
{
var subjectCoureseMappingDto = new SubjectCourseMappingDto();
ViewBag.courses = await _academicService.GetAllCourses();
ViewBag.branch = await _academicService.GetAllBranches();
ViewBag.academicSession = await _dropdownHelper.getAllSession();
ViewBag.semesters = await _dropdownHelper.Emptylist();
ViewBag.subjects = await _dropdownHelper.GetSubjectName();

var subjectcourse = _subjectCourseMappingService.GetCategoryList();

try
{
var SubjectCourseMapping = _subjectCourseMappingService.GetById(Convert.ToInt32(id));
if (SubjectCourseMapping != null)
{

subjectCoureseMappingDto =
_mapper.Map<SubjectCourseMappingDto>(SubjectCourseMapping);
subjectCoureseMappingDto.LstSubjectCourse =
_mapper.Map<IReadOnlyList<SubjectCourseMappingDto>>(subjectcourse);

58
 else
{
subjectCoureseMappingDto.LstSubjectCourse =
_mapper.Map<IReadOnlyList<SubjectCourseMappingDto>>(subjectcourse);
}
}
catch { }

return View(subjectCoureseMappingDto);
}

[HttpPost]
public async Task<IActionResult> SubjectCoureseMapping(SubjectCourseMappingDto model)
{
try
{
ViewBag.courses = await _academicService.GetAllCourses();
ViewBag.branch = await _academicService.GetAllBranches();
ViewBag.academicSession = await _dropdownHelper.getAllSession();
ViewBag.semesters = await _dropdownHelper.GetAllSemesters();
ViewBag.subjects = await _dropdownHelper.GetSubjectName();

if (model == null) return BadRequest("Invalid model");

var SubjectCourseMapping = _mapper.Map<SubjectCourseMapping>(model);

SubjectCourseMapping.CollageId = CurrentUser.CollegeId;
SubjectCourseMapping.IsActive = true;
SubjectCourseMapping.EntryDate = DateTime.Now;
SubjectCourseMapping.Entryby = CurrentUser.UserID;

var isUpdate = SubjectCourseMapping.ScourseMappingId != 0;

(isUpdate ? _subjectCourseMappingService.Update :
(Action<SubjectCourseMapping>)_subjectCourseMappingService.Save)(SubjectCourseMapping);

ShowSuccessMessage("Success", isUpdate ? "Data Updated Successfully" : "Data Saved

Successfully", false);

return RedirectToAction("SubjectCoureseMapping");
}
catch (Exception ex)
{

ShowErrorMessage("Error", "Something went wrong");

return View();
}

}
public IActionResult DeleteSubjectCoureseMapping(int id)
{
try

59
 {
if (id == 0)
{
TempData["ErrorMessage"] = "headCode is empty";
}
else
{
_subjectCourseMappingService.Delete(id);
TempData["SuccessMessage"] = "Delete data Successfully";

}
catch (Exception ex)
{
TempData["ErrorMessage"] = "Something went wrong";
}
return RedirectToAction("SubjectCoureseMapping");
}

public IActionResult GetBranchByCourseId(int CourseId)

{
var branches = _courseMasterService.GetBranchByCourseId(CourseId);
return Json(branches);
}
public async Task<IActionResult> GetSemesterByBranchId(int CourseId)
{
var branches = await _dropdownHelper.GetSemesterByBranchId(CourseId);
return Json(branches);
}

Academic.cshtml

@using System.Data;

@model ERP.Dto.AcademicMaster.CourseMasterDto;

@{

ViewData["Title"] = "CourseMaster";

60
Layout = "~/Areas/Admin/Views/Shared/_AdminLayout.cshtml";

<head>

<link rel="stylesheet" href="/assets/css/pagestyle.css">

<link rel="stylesheet" href="/assets/css/style.css">

</head>

<br />

<!-- Page Header -->

<div class="page-header">

<div class="row">

<div class="col-sm-12">

<div class="page-sub-header">

<h3 class="page-title">Academic Master</h3>

<ul class="breadcrumb">

<li class="breadcrumb-item"><a href="#">Academic Master</a></li>

<li class="breadcrumb-item active"> Course Master</li>

</ul>

</div>

</div>

</div>

</div>

<!-- /Page Header -->

<div class="row">

<div class="col-lg-12 col-md-12 col-sm-12 col-12">

61
 @section notification {

<partial name="_Notification.cshtml" />

<form asp-controller="Academic" asp-action="CourseMaster"

method="post">

<div class="card student-group-form">

<div class="card-body row">

<br />

<br />

<input type="hidden" id="CourseId" />

<div class="col-lg-3 col-md-6">

<div class="form-group local-forms">

<label>Course Type<span class="login-danger" asp-validation-

for="CourseType">*</span></label>

<select class="form-control form-select" id="CourseType" asp-

for="CourseType">

<option>--Select--</option>

<option value="1">Graduate Course</option>

<option value="2"> Post Graduate Course</option>

<option value="3">Diploma Course</option>

</select>

</div>

</div>

<div class="col-lg-4 col-md-6">

62
 <div class="form-group local-forms">

<label>Course Category<span class="login-danger" asp-

validation-for="CourseCategory">*</span></label>

<select class="form-control form-select" id="CourseCategory"

asp-for="CourseCategory">

<option>Course Category</option>

<option value="1">Regular</option>

<option value="2">Private</option>

<option value="3">Part time</option>

</select>

</div>

</div>

<div class="col-12 col-sm-4">

<div class="form-group local-forms">

<label>Course Name<span class="login-danger" asp-

validation-for="CourseName">*</span></label>

<input type="text" asp-for="CourseName" class="form-control"

placeholder="Course Name" />

</div>

</div>

63
 <div class="col-lg-3 col-md-6">

<div class="form-group local-forms">

<label>Course Duration(In Years)<span class="login-danger"

asp-validation-for="CourseDuration">*</span></label>

<input type="text" asp-for="CourseDuration" class="form-

control" placeholder="Course Duration(In Years)" />

</div>

</div>

<div class="col-lg-4 col-md-6">

<div class="form-group local-forms">

<label>Short Name <span class="login-danger" asp-validation-

for="ShortName">*</span></label>

<input asp-for="ShortName" type="text" id="ShortName"

class="form-control" placeholder="Short Name">

</div>

</div>

<div class="col-lg-4 col-md-6">

<div class="form-group local-forms">

<label>Course Category <span class="login-danger" asp-

validation-for="Type">*</span></label>

<select asp-for="Type" class="form-control form-select"

id="Type">

<option>Type</option>

64
 <option value="1">Year</option>

<option value="2">Semester</option>

</select>

</div>

</div>

<div class="col-lg-4 col-md-6">

<div class="form-group local-forms" style="margin-top: -28px;">

Active:&nbsp;&nbsp;&nbsp;<input name="Active"

type="checkbox" id="Active" class="checkbox">

</div>

</div>

<div class="button-row d-flex mt-4 btns">

<button class="btn btn-primary" type="submit"

id="btnSave">Submit</button>

</div>

</div>

</div>

</form>

</div>

</div>

65
 <script

src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>

<script>

$(document).ready(function () {

})

$("#btnSave").click(function () {

});

$("#BtnUpdate").click(function () {

});

$("#btncancelButton").click(function () {

});

</script>

FUTURE SCOPE

Following modification or upgrades can be done in system.

1. More than one company can be integrated through this software.

2. Web services can be used to know exact donation status of packets.

3. Client can check there donation delivery status online.

CONCLUSION:
During extended interviews with shoppers, we found different processes leading to

the successful development and deployment of portals. The portal doesn’t have to be

66
expensive. It should support multiple campus goals. It is clear that the functionality

of a portal develops over time.

“https://navyalerp.varcas.org/” is not only a web portal. It is a live project of

CollegeErp. In future we will add more and more features on it. This portal can be

used by any shopping store.

67