FREELANCE MANAGEMENT SYSTEM

A PROJECT REPORT
Submitted by
GOPINATH P
(Reg.No:P19LA 0009)
In partial fulfilment for the award of the degree
Of
MASTER OF COMPUTER APPLICATION
PROJECT ADVISOR
D.Nandhini MCA., M.Phil

PG & RESEARCH DEPARTMENT OF COMPUTER SCIENCE

NEHRU MEMORIAL COLLEGE(AUTONOMOUS)
(NATIONAL ACCREDITED WITH ‘A’ GRADE BY NAAC)
PUTHANAMPATTI-621 007
APRIL 2021
D.Nandhini MCA., M.Phil
Associate Professor,
Department of Computer Science,
Nehru Memorial College,
Puthanampatti-621 007.

CERTIFICATE
This is to certify that the project report entitled “Freelance Management System” is
a bonafide work done.
BY
NAME : GOPINATH P

REG.NO : P19LA0009
Submitted to Nehru Memorial College(Autonomous), Puthanampatti, Tiruchirapalli during
6th semester in Partial fulfilment of the requirement for the award of the degree of
Master of Computer Application.
I further certify that the project work carried out by him is an independent work
done under my supervision and guidance and it is not presented anywhere else.

HEAD OF THE DEPARTMENT PROJECT ADVISOR

(Dr.MMuralidharan) (D.NANDHINI))

Submitted on __________________for the Project Viva -Voce examination to be held

on____________________

1. Examiner 2. Examiner
 ACKNOWLEDGEMENT

I thank God almighty for having gracefully blessed me with knowledge, skill and
enthusiasm in completing the project.
First and foremost I thank to my parents for their blessing throughout my life. I also
extend my sincere thanks to my beloved family members.
I would like to express my thanks to the honorable Chairman, governing body
Mr.M. PONNABALAM M.A., M.Sc., Nehru Memorial College, Puthanampatti for providing
me with necessary facilities for providing my project work without any hitches.
I would like to express my thanks to the president Er. PON. BALASUBRAMANIAN,
Nehru Memorial College, Puthanampatti for his support and encouragement for completing
the project work on time.
I express my science gratitude to Dr. A. R. PONPERIASAMY M.Sc (Phy)., M.Sc
(CS)., PGDCA., M.C.A., M.Phil., Ph.D.,Principal, Nehru Memorial College for having given
me the opportunity and for making my dreams come true.
Words are few but feeling are more to Dr.M.MURALIDHARAN M.Sc., M.Phil., PGDCA .,
PGDHET., Ph.D., Head, Department of Computer Science of Nehru Memorial College
Puthanampatti for his guidance, motivation right from the beginning of my studies. The
project will not be fulfill unless I say my deepest thanks to my guide D.NANDHINI
MCA.,M.Phil.,. Assistant Professor, Department of Computer Science , Nehru Memorial
College, Puthanampatti for her constant support and encouragement thought out my project.
I convey my thanks to all staff member of my department for their efforts
involvement and interest that they have shown in various aspects during my course.
It is a great pleasure to be able to thank all the people who helped me turn this system
from a list of good ideas.

(P.GOPINATH)
 Freelance Management System
Abstract:
Freelance job is where you’re a temporary contract worker, rather than a permanent
employee. Depending on your level of expertise, it could be possible to work part-time hours,
but make full-time pay. Having control over your work load, the clients you work with, and
your income is a big benefit of freelancing. Freelancing is doing a job under contract rather
than full employment. Usually, people who freelance are selfemployed and for whom they
will work and they decide for how long. Freelancing offers the lot of freedom and flexibility
which regular jobs cannot. The freelancer can choose the type of the work, time of the day
can work and how long they work, a location they work and volume of work take on. The
freelancer can control work relationship and control work load. Platform freelancing has
many websites and anyone can register as freelancers or job posters. There is a discussion
forum to build up friendly environment between freelancers and clients. All they can work
without any language issue. For these solutions, the system is designed according to four sub
modules such as user validation module, file sharing module and manage profile. Users of the
system are Job poster, Freelancer (Jobseeker). Inputs of the system are Details of the Job
poster, Freelancer, Job, gig. Outputs of the system are Overall rating. Processes of the system
are collected data, analyze data and job posting, creating gigs, discussion and complete the
job. It is distributed among 20 selected users and collects their feedback. Keywords -
Freelancing, Freelancer.
 Content

S. No Title Page No

Introduction
1.
System Analysis
2. 2.1 Existing system
2.2 Proposed system
Project Description
3. 3.1 Modules and Description:
System Requirement
4. 4.1 Hardware requirement
4.2 Software requirement
Software Description
5. 5.1 Front end
5.2 Backend
System Design
6. 6.1 Input design
6.2 Output design
6.3 Data flow diagram
Implementation And Maintenance
7. Testing
Conclusion
8.
Bibliography
9.
Appendices
10. 10.1 Coding
10.2 Screen Layouts
 Introduction

Introduction:
A freelancer is a self-employed person who offers services to clients. These services
often, though not necessarily, are offered to businesses through the proliferation of sharing
economy platforms like Task Rabbit, Mechanical Turk, or Up work. However, individuals
can offer their services directly to clients, without third-party resources that often take a cut
of the pay. Freelancing is flexible. You can often work full- or part-time on projects of your
choice, at the hours that are convenient for you. Although clients can (and usually will) set
specifications for the work they want to be done, a freelancer is still an independent
contractor, not an employee. You'd be free to control how the work is completed. However, if
your clients don't like the final product, you might find yourself out of a gig. Freelancing
allows you to set your own price for your services, which is often higher than what you'd
make as an employee doing the same work. Make sure you charge enough to cover your
overhead and to compensate you fairly for the time it will take you to do the work. You'll
probably want to take on any client who will hire you when you're starting out, but you also
have the option to not take on difficult clients, especially as you grow. You can even tell
clients you no longer wish to work for them.
Nearly every type of service needed by a business can be provided by a freelancer. Some of
the most common freelance opportunities include:
 Project Management
 Web Design/Development
 Software developer
 Writing / Editing
 Graphic Design
 System Analysis
Existing System:
The existing system is a semi-automated at where the information is stored in the form of
excel sheets in disk drives. The information sharing to the Volunteers, Group members, etc. is
through mailing feature only. The information storage and maintenance is more critical in this
system. Tracking the member‘s activities and progress of the work is a tedious job here. This
system cannot provide the information sharing by 24x7 days.

Disadvantages Of Existing System

 More manpower.
 Time consuming.
 Consumes large volume of pare work.
 Needs manual calculations.
 No direct role for the higher officials.
To avoid all these limitations and make the working more accurately the system to be
computerized
.
Proposed System:

 The development of this new system objective is to provide the solution to the
problems of existing system. By using this new system, we can fully automate the
entire process of the current system. The new system would like to make as web-
enabled so that the information can be shared between the members at any time using
the respective credentials. To track the status of an individual process, the status
update can be centralized using the new system. Being a web-enabled system, the
process can be accessed across the world over net.

 This system also providing the features like , Mailing between the members; updating
the process status in centralized location; generated reports can also be exporting to
the applications like MS-Excel, PDF format, etc. In this new system, the members
like Donors can give their valuable feedback to the Volunteers so that the Volunteers
can check their progress of the tasks.

 The entire process categorized as different modules like Admin module, Volunteer
module, etc. at where we can classify the functionality as an individual process.

 Using the new system entering into Admin module we can perform….

Advantages of Proposed System

 Ensure data accuracy.

 Proper control of the higher officials.
 Reduce the damages of the machines.
 Minimize manual data entry.
 Minimum time needed for the various processing.
 Greater efficiency.
 Better service.
 User friendliness and interactive.
 Minimum time required.
 Project Description

Project Description:
Implementation is the stage in the project where the theoretical design is turned into a
working system. The implementation phase constructs, installs and operates the new system.
The most crucial stage in achieving a new successful system is that it will work efficiently
and effectively.
There are several activities involved while implementing a new project.
• End user Training
• End user Education
• Training on the application software.

Project Structure:
 Modules and Description:
Modules:
The system after careful analysis has been identified to be presented with the
following modules:

Main Modules:
1. Admin
2. Client
3. Freelancer

Sub Modules:
1. Registration
2. Login
3. Admin_home
4. Freelance home
5. Client_home
6. Dashboard
7. Job post
8. Place your bid or gig
9. Process Or Task Maintain
10. Profile
11. Task completed

Module Description:
Admin Module:
Administrator can edit, add, delete and update any sub modules. He can keep track of
all the information in the corresponding modules. The Admin Module includes five sub
modules. They are
1. Login
2. Freelancer
3. Client
.4 Project
5. logout

Login:
Administrator have login used to login to see the information.
Freelancer Module:
Administrator can add new user and delete any existing employee if necessary.

Client Module
Administrator can add new Client and delete any existing employee if necessary.

Project:
Administrator can add new Project List and delete any existing employee if necessary2.
Requirements Specification:

Logout:
Logout is exit from your Admin account .

Freelancer Module:
1. Register
2. Login
3. Freelancer home
4. profile
5. Browser Your project
6. Search Project
7. Place bid
8. Process
9. Logout.

Register:
Register system is the module, which checks for a valid candidate when the
freelancer enters his , name, password, email, phone number, gender, city, and link to the
login page. As user id rules the system, with a help of user id a person is known by his
uniqueness of his user id. As it is to provide the viable candidate system, so the user id is
being validated with password in different cases to validate the genuinely of the candidate.
This register for security purpose for authorized user.

Login:
Login system is the module, which checks for a valid candidate when the user enters
his login-id, user-id, password and link to the main page. As user id rules the system, with a
help of user id a person is known by his uniqueness of his user id. As it is to provide the
viable candidate system, so the user id is being validated with password in different cases to
validate the genuinely of the candidate. This login for security purpose for authorized user.

Freelancer Home:
Freelancer Home module is a main module of the project this used to main the profile
And browser Your project.
Profile:
Profile module Used to store your personal information like name and email id
This information you give in register information in there in profile module.

Browser your project:

This is module used to way of feed your project list there are list of project list which
skill related project your pick and place your bid.

Search Project;
Search Module is search a specific title or skill related filter to search and show the
list.

Place bid:
Place bid module is if you like a job and related to your skill so you place bid that is
your price value and time summary and qualification that send to client if it is like your
profile selected.

Process:
Process module is your project status related module your project are process or
completed status.

Logout:
Logout is exit from your Freelance account .

Client Module:
1. Register
2. Login
3. Client home
4. profile
5. Post project
6. Process
7. Show bid
8. Log out

Register:
Register system is the module, which checks for a valid candidate when the
freelancer enters his , name, password, email, phone number, gender, city, and link to the
login page. As user id rules the system, with a help of user id a person is known by his
uniqueness of his user id. As it is to provide the viable candidate system, so the user id is
being validated with password in different cases to validate the genuinely of the candidate.
This register for security purpose for authorized user.
Login:
Login system is the module, which checks for a valid candidate when the user enters
his login-id, user-id, password and link to the main page. As user id rules the system, with a
help of user id a person is known by his uniqueness of his user id. As it is to provide the
viable candidate system, so the user id is being validated with password in different cases to
validate the genuinely of the candidate. This login for security purpose for authorized user.

Client Home:
Client Home module is a main module of the project this used to main the profile
And browser Your project.

Profile:
Profile module Used to store your personal information like name and email id This
information you give in register information in there in profile module.

Post Project:
Post Project module is client our project post like project title , required skill and
duration, amount , description , qualification all details to post the job .

Process:
Process module is your project status related module your project are process or
completed status.

Show bid:
This is module is how many freelancers bid your project and you select one
freelancers who is work your project based on skill and other project related information.

Logout:
Logout is exit from your Client account .
 System Requirements
System Requirements
The hardware and software specification specifies the minimum hardware and software
required to run the project. The hardware configuration specified below is not by any means
the optimal hardware requirements. The software specification given below is just the
minimum requirements, and the performance of the system may be slow on such system.

Hardware Requirements

 System : Pentium IV 2.4 GHz

 Hard Disk : 500 GB
 Floppy Drive : 10.44 MB
 Monitor : 15 VGA colour
 Mouse : Logitech.
 Keyboard : 110 keys enhanced
 RAM : 4 GB

Software Requirements

 Operation System : Windows

 Front End : Html, CSS, Angular , Typescript
 Back End : Java, Spring , Spring Boot, Jpa, hibernate, CURD
 Database : Mysql
 Software : Vscode, Postman, Heidisql, Mysql Workbench
 SOFTWARE DESCRIPTION
Front end:
Angular

Introduction To Angular:

 Angular is a platform and framework for building single-page client applications

using HTML and TypeScript. Angular is written in TypeScript. It implements core
and optional functionality as a set of TypeScript libraries that you import into your
apps.

 The architecture of an Angular application relies on certain fundamental concepts.

The basic building blocks of the Angular framework are Angular components that are
organized into NgModules. NgModules collect related code into functional sets; an
Angular app is defined by a set of NgModules. An app always has at least a root
module that enables bootstrapping, and typically has many more feature modules.
 Components define views, which are sets of screen elements that Angular can choose
among and modify according to your program logic and data.
 Components use services, which provide specific functionality not directly related to
views. Service providers can be injected into components as dependencies, making
your code modular, reusable, and efficient.
 Modules, components and services are classes that use decorators. These decorators
mark their type and provide metadata that tells Angular how to use them.
 The metadata for a component class associates it with a template that defines a view.
A template combines ordinary HTML with Angular directives and binding markup
that allow Angular to modify the HTML before rendering it for display.
 The metadata for a service class provides the information Angular needs to make it
available to components through dependency injection (DI).

 An app's components typically define many views, arranged hierarchically. Angular

provides the Router service to help you define navigation paths among views. The
router provides sophisticated in-browser navigational capabilities.

Modules:
 Angular NgModules differ from and complement JavaScript (ES2015) modules. An
NgModule declares a compilation context for a set of components that is dedicated to
an application domain, a workflow, or a closely related set of capabilities. An
NgModule can associate its components with related code, such as services, to form
functional units.
 Every Angular app has a root module, conventionally named AppModule, which
provides the bootstrap mechanism that launches the application. An app typically
contains many functional modules.
  Like JavaScript modules, NgModules can import functionality from other
NgModules, and allow their own functionality to be exported and used by other
NgModules. For example, to use the router service in your app, you import the Router
NgModule.
 Organizing your code into distinct functional modules helps in managing
development of complex applications, and in designing for reusability. In addition,
this technique lets you take advantage of lazy-loading—that is, loading modules on
demand—to minimize the amount of code that needs to be loaded at startup.

Components:
 Every Angular application has at least one component, the root component that
connects a component hierarchy with the page document object model (DOM). Each
component defines a class that contains application data and logic, and is associated
with an HTML template that defines a view to be displayed in a target environment.
 The @Component() decorator identifies the class immediately below it as a
component, and provides the template and related component-specific metadata.

Templates, directives, and data binding

 A template combines HTML with Angular markup that can modify HTML elements
before they are displayed. Template directives provide program logic, and binding
markup connects your application data and the DOM. There are two types of data
binding:
 Event binding lets your app respond to user input in the target environment by
updating your application data.
 Property binding lets you interpolate values that are computed from your application
data into the HTML.
 Before a view is displayed, Angular evaluates the directives and resolves the binding
syntax in the template to modify the HTML elements and the DOM, according to
your program data and logic. Angular supports two-way data binding, meaning that
changes in the DOM, such as user choices, are also reflected in your program data.
 Your templates can use pipes to improve the user experience by transforming values
for display. For example, use pipes to display dates and currency values that are
appropriate for a user's locale. Angular provides predefined pipes for common
transformations, and you can also define your own pipes.

Service and Dependency Injection:

 For data or logic that isn't associated with a specific view, and that you want to share
across components, you create a service class. A service class definition is
immediately preceded by the @Injectable() decorator. The decorator provides the
metadata that allows other providers to be injected as dependencies into your class.
  Dependency injection (DI) lets you keep your component classes lean and efficient.
They don't fetch data from the server, validate user input, or log directly to the
console; they delegate such tasks to services.

Routing:
 The router maps URL-like paths to views instead of pages. When a user performs an
action, such as clicking a link, that would load a new page in the browser, the router
intercepts the browser's behavior, and shows or hides view hierarchies.
 If the router determines that the current application state requires particular
functionality, and the module that defines it hasn't been loaded, the router can lazy-
load the module on demand.
 The router interprets a link URL according to your app's view navigation rules and
data state. You can navigate to new views when the user clicks a button or selects
from a drop box, or in response to some other stimulus from any source. The router
logs activity in the browser's history, so the back and forward buttons work as well.

Structure:
Front end folder Structure:
 Back end

Back End:
Java:
 Java is an object-oriented programming language developed by Sun Microsystems,
and it was released in 1995.
 James Gosling initially developed Java in Sun Microsystems (which was later merged
with Oracle Corporation).
 Java is a set of features of C and C++. It has obtained its format from C, and OOP
features from C++.
 Java programs are platform independent which means they can be run on any
operating system with any processor as long as the Java interpreter is available on that
system.
 Java code that runs on one platform does not need to be recompiled to run on another
platform; it's called write once, run anywhere(WORA).
 Java Virtual Machine (JVM) executes Java code, but it has been written in platform-
specific languages such as C/C++/ASM, etc. JVM is not written in Java and hence
cannot be platform independent, and Java interpreter is a part of JVM.

Spring :

 It was developed by Rod Johnson in 2003. Spring framework makes the easy
development of JavaEE application.
 Spring is a lightweight framework. It can be thought of as a framework of frameworks
because it provides support to various frameworks such as Struts, Hibernate, Tapestry,
EJB, JSF, etc. The framework, in broader sense, can be defined as a structure where
we find solution of the various technical problems.
 The Spring framework comprises several modules such as IOC, AOP, DAO, Context,
ORM, WEB MVC etc. We will learn these modules in next page. Let's understand the
IOC and Dependency Injection first.

Spring Moules:
 The Spring framework comprises of many modules such as core, beans, context,
expression language, AOP, Aspects, Instrumentation, JDBC, ORM, OXM, JMS,
Transaction, Web, Servlet, Struts etc. These modules are grouped into Test, Core
Container, AOP, Aspects, Instrumentation, Data Access / Integration, Web (MVC /
Remoting) as displayed in the following diagram.
Spring Boot:
Spring Boot provides a good platform for Java developers to develop a stand-alone and
production-grade spring application that you can just run. You can get started with minimum
configurations without the need for an entire Spring configuration setup.

 It provides a flexible way to configure Java Beans, XML configurations, and

Database Transactions.
 It provides a powerful batch processing and manages REST endpoints.
 In Spring Boot, everything is auto configured; no manual configurations are needed.
 It offers annotation-based spring application
 Eases dependency management
 It includes Embedded Servlet Container
Spring Boot Project Structure:
CURD:

computer programming, the acronym CRUD stands for create, read, update an and
delete. These are the four basic functions of persistent storage. Also, each letter in the
acronym can refer to all functions executed in relational database applications and mapped to
a standard HTTP method, SQL statement or DDS operation.

MySQL:
MySQL is an open-source
source relational database management system (RDBMS). It is the
most popular database system used with PHP. MySQL is developed, distributed, and
supported by Oracle Corporation.

 The data in a MySQL database are stored in tables which con consists
sists of columns and
rows.
 MySQL is a database system that runs on a server.
 MySQL is ideal for both small and large applications.
 MySQL is very fast, reliable, and easy to use database system.It uses standard SQL
 MySQL compiles on a number of platforms.
Postman:
Postman is an API(application programming interface) development tool which helps to
build, test and modify APIs. Almost any functionality that could be needed by any developer
is encapsulated in this tool. It is used by over 5 million developers every month to make their
API development easy and simple.

Vscode:
Visual Studio Code is a lightweight but powerful source code editor which runs on your
desktop and is available for Windows, macOS and Linux. It comes with built-in support for
JavaScript, TypeScript and Node.js and has a rich ecosystem of extensions for other
languages (such as C++, C#, Java, Python, PHP, Go) and runtimes (such as .NET and Unity)

HeidiSQL:
HeidiSQL is a useful and reliable tool designed for web developers using the popular
MySQL server, Microsoft SQL databases and PostgreSQL. It enables you to browse and edit
data, create and edit tables, views, procedures, triggers and scheduled events. Also, you can
export structure and data either to SQL file, clipboard or to other servers.
 System Design

Freelancer Management System

Client Freelancer admin

Database
Register
Admin Login

login
Register

login
Main Module

Main Module
 Input Design

Register:
Login:
Post Project:
Place Your Bid:
 Output Design:
Register

Project list:

Completed Project:
DATA FLOW DIAGRAM
DFD Level 0

Register

Freelance
Management Database
System

Login

DFD Level 1

Admin Login
View Details

Login

Client List Freelancer List Project List

Database
DFD Level 2

Freelancer

Register
Database

Login

Project list

Place bid

Completed Project
DFD Level 3

Client

Data Base

Register

Login

Post project

Process

Completed
ER Diagram
An entity relationship model al also called an entity-relationship(ER)
relationship(ER) diagram is a
graphical representation of entities and their relationship to each other, typically used in
computing in regard to the organization of data within databases or information systems. An
entity is a piece of data-an
an object or concept about which data is stored.
Use Case Diagram
DATABASE DESIGN

Database Design:
Database with Normalization:
Database Normalization is a technique of organizing the data in the database.
Normalization is a systematic approach of decomposing tables to eliminate data redundancy
and undesirable characteristics like Insertion, Update and Deletion Anomalies. It is a multi-
step process that puts data into tabular form by removing duplicated data from the relation
tables.
Normalization:
“Normalization is the process of converting complex data structures into simple and
stable data structures.”

Normalization is used for mainly two purpose,

 Eliminating redundant (useless) data.

 Ensuring data dependencies make sense i.e. data is logically stored.

Normalization Steps:
First Normal form (1NF). Any repeating groups have been removed so there is a single
value at the intersection of each row and column of the table.

First normal form (1NF)

As per the rule of first normal form, an attribute (column) of a table cannot hold multiple
values. It should hold only atomic values.

 No non-prime attribute is dependent on the proper subset of any candidate key of

table.

An attribute that is not part of any candidate key is known as non-prime attribute.

Table type:
1. One to one
2. One to many
3. Many to one
Database Table Schema:
 Implementation
Implementation
This project “Freelance Management System” web application developed using
Angular Framework, Typescript as front-end and java, spring boot, mysql as backend.
The existing system caused long time transmission process but the system developed now has
a very good user-friendly tool, which has a menu-based interface.
All the server process are done through tomcat server.

Testing & Maintenance

The development process involves various types of testing. Each test type
addresses a specific testing requirement. The most common types of testing involved in
the development process are:
 Unit Test
 System Test
 Integration Test
 Functional Test
 Performance Test
 Beta Test
 Acceptance Test
 Validation Test

Unit Testing
The first test in the development process is the unit test. The source code is
normally divided into modules, which in turn are divided into smaller units called units.
These units have specific behavior. The test done on these units of code is called unit
test. Unit test depends upon the language on which the project is developed. Unit tests
ensure that each unique path of the project performs accurately to the documented
specifications and contains clearly defined inputs and expected results.
System Testing
Several modules constitute a project. If the project is long-term project, several
developers write the modules. Once all the modules are integrated, several errors may
arise. The testing done at this stage is called system test. System testing ensures that
the entire integrated software system meets requirements. It tests a configuration to
ensure known and predictable results. System testing is based on process descriptions
and flows, emphasizing pre-driven process links and integration points.
Testing a specific hardware/software installation. This is typically performed on
a COTS (commercial off the shelf) system or any other system comprised of disparate
parts where custom configurations and/or unique installations are the norm.
Functional Testing
Functional test can be defined as testing two or more modules together with the
intent of finding defects, demonstrating that defects are not present, verifying that the
module performs its intended functions as stated in the specification and establishing
confidence that a program does what it is supposed to do.
Integration Testing

Testing in which modules are combined and tested as a group. Modules are
typically code modules, individual applications, source and destination applications on
a network, etc. Integration Testing follows unit testing and precedes system
testing.Testing after the product is code complete. Betas are often widely distributed or
even distributed to the public at large in hopes that they will buy the final product when
it is released.

White Box Testing

Testing based on an analysis of internal workings and structure of a piece of
software. This testing can be done sing the percentage value of load and energy. The
tester should know what exactly is done in the internal program. Includes techniques
such as Branch Testing and Path Testing. Also known as Structural Testing and Glass
Box Testing.

Black Box Testing

Testing without knowledge of the internal workings of the item being tested.
Tests are usually functional. This testing can be done by the user who has no
knowledge of how the shortest path is found.

Validation Testing
The process of evaluating software during the development process or at the
end of the development process to determine whether it satisfies specified business
requirements. Validation Testing ensures that the product actually meets the client's
needs. Enter the ten digits mobile number for the test and if the number is correct,
accept and proceed to the next page. Otherwise it will display an error message.

Maintenance:
Software maintenance is the modification of a software product after delivery to
correct faults, to improve performance or other attributes. Software maintenance is a very
broad activity that includes error corrections, enhancements of capabilities, deletion of
absolute capabilities and optimization. Because change is inevitable, mechanism must be
developed for evaluation, controlling and making modifications. So any work done to change
the software after it is in operation is considered to be maintenance work.
Maintenance Types:

Preventive Maintenance:
Preventive maintenance is maintenance performed in an attempt to avoid failures,
unnecessary production loss and safety violations.

Corrective Maintenance:
This maintenance is often most expensive because worn equipment can damage
other parts and cause multiple damage. Corrective maintenance is probably the most
commonly used approach, but it is easy to see its limitations, if the equipment needs to be
replaced, the cost of replacing it alone can be substantial.

Adaptive Maintenance:
 The adaptive maintenance modifiers software to properly interface with a
changing environment.
This project was the corrective maintenance because if the equipment needs to be replaced.
The cost of replacing it alone can be substantial
Conclusion
Freelance Management System Fixed-price projects are automatically marked complete
once your bid amount is paid in full. Hourly projects have to be ended manually by your
employer before they are marked complete. Feel free to ask your employer for the project’s
completion after your submitted work is reviewed and paid for. The Jobs Completed is the
percentage of the projects you have successfully completed versus the total number of
awarded projects you accepted.The On Budget and On Time percentages reflect your
previous employers’ feedback on whether or not you completed their projects for the agreed
price and on the agreed deadline. The Preferred Freelancer Program pools the best talent
,creating a community of elite freelancers whom we call Preferred Freelancers. If you get
accepted into the program, you will receive exclusive invitations to work on high-value
projects, and you will get the Preferred Freelancer badge to make your profile stand out,
among other perks.
Bibliography
Primary Sources:

 Angular the Complete Guide by Maximilian Schwarzmüller.

 Spring Boot in Action by Josh Long and Kenny Bastani

Websites:
 Angular official site
https://angular.io/docs
 Spring and Spring boot Official site and Javatpoint

https://www.javatpoint.com/spring-boot-tutorial

https://spring.io/guides
 Appendix
Source Code:
Front End:

Register.html:

<mat-card class="card">
<mat-card-title class="title">Sign form</mat-card-title>

<div class="container">
<form [formGroup]="loginForm" (ngSubmit)="onSubmit();">

<div class="form-group">
<label>Enter Your Name:</label>
<input type="name" class="form-control" formControlName="name"
placeholder="Enter Your Name"
autocomplete="on">
</div>

<div class="form-group">
<label>Email address:</label>
<input type="email" class="form-control" formControlName="email"
placeholder="Enter Your Email"
autocomplete="on">
<small class="form-text text-muted">{{msg}}</small>
<small class="form-text text-muted"
*ngIf="loginForm.controls.email.touched &&
loginForm.controls.email.errors?.required">
Please enter email address.!
</small>

<small class="form-text text-muted"

*ngIf="loginForm.controls.email.touched &&
loginForm.controls.email.errors?.email">
 Email address not well formed.!
</small>
</div>
<div class="form-group">
<label>Password:</label>
<input type="password" class="form-control" formControlName="password"
placeholder="Password" autocomplete="on"
>
</div>
<div class="form-group">
<label>Enter Your Number:</label>
<input type="text" class="form-control" formControlName="number"
placeholder="Enter Your Number"
autocomplete="on">

</div>
<div class="form-group">
<label>Enter Your City</label>
<input type="text" class="form-control" formControlName="country"
placeholder="Enter Your City"
autocomplete="on">
</div>
<div class="form-group">
<label>Gender</label><br/>
<mat-form-field appearance="fill">
<mat-label>Gender</mat-label>
<mat-select name="gender" [(ngModel)]="selectedGender"
[ngModelOptions]="{standalone: true}">
<mat-option *ngFor="let g of gender" [value]="g.value">
{{g.viewValue}}
</mat-option>
</mat-select>
</mat-form-field>
 </div>

<!-- <button type="submit" class="btn btn-primary" [disabled]="!loginForm.valid" mat-

raised-button>Sign Up</button> -->
<button type="submit" class="btn btn-primary" mat-raised-button>
Sign Up
</button>
</form>
<div class="form-group">
<span class="login">Already Have a Account Plase Login:</span>
<span style="padding-left: 10px"><a (click)="loginuser()">Login</a></span>
</div>
</div>
</mat-card>
Register.Ts
import {Component, OnInit} from '@angular/core';
import {FormControl, FormGroup, Validators} from '@angular/forms';
import {Router} from '@angular/router';
import {LoginService} from '../service/login.service';
interface Gender {
value: string;
viewValue: string;
}
@Component({
selector: 'app-signup',
templateUrl: './signup.component.html',
styleUrls: ['./signup.component.css']
})

export class SignupComponent implements OnInit {

loginForm: FormGroup;
msg = ' ';
selectedValue: string;
selectedGender: string;
gender: Gender[] = [
{value: 'Male', viewValue: ' Male'},
{value: 'Female', viewValue: 'Female'},
{value: 'Trans Gender', viewValue: 'Trans Gender'},
];

constructor(private routers: Router, public loginservice: LoginService) {

this.loginForm = new FormGroup({
name: new FormControl('', [Validators.required]),
email: new FormControl('', [Validators.required, Validators.email]),
password: new FormControl('', [Validators.required]),
number: new FormControl('', [Validators.required]),
country: new FormControl('', [Validators.required]),
account_type: new FormControl('', Validators.required),
gender: new FormControl('', Validators.required),
});
}

ngOnInit(): void {
}

loginuser() {
this.routers.navigate(['/login-home']);
}

onSubmit() {
console.log(this.loginForm.value);
console.log(this.selectedGender);
 console.log(this.selectedValue);
const signindata = {
name: this.loginForm.value.name,
email: this.loginForm.value.email,
password: this.loginForm.value.password,
number: this.loginForm.value.number,
country: this.loginForm.value.country,
gender: this.selectedGender
};
this.loginservice.signin(signindata).subscribe(data => {
console.log('Succesffuly create Your Account', data);
this.routers.navigate(['/login-home']);
}, error => {
this.msg = 'Your Email Id already exist';
}
);

this.loginForm.reset();
}
}
Login.html
<mat-card class="card">
<mat-card-title class="title">Login form</mat-card-title>
<p *ngIf="expression">Please Enter Your Valid Email and Password</p>
<div class="container">
<form [formGroup]="loginForm" (ngSubmit)="onSubmit();" novalidate>
<small class="form-text text-muted">{{msg}}</small>
<div class="form-group">
<label>Email address</label>
<input type="email" class="form-control" formControlName="email"
placeholder="Enter email" autocomplete="on"
[(ngModel)]="user.email">
<small class="form-text text-muted"
*ngIf="loginForm.controls.email.touched &&
loginForm.controls.email.errors?.required">
Please enter email address.!
</small>

<small class="form-text text-muted"

*ngIf="loginForm.controls.email.touched &&
loginForm.controls.email.errors?.email">
Email address not well formed.!
</small>
</div>
<div class="form-group">
<label>Password</label>
<input type="password" class="form-control" formControlName="password"
placeholder="Password" autocomplete="on">
</div>
<button type="submit" class="btn btn-primary" [disabled]="!loginForm.valid" mat-
raised-button>Login..</button>
<!--<button type="submit" class="btn btn-primary" mat-raised-button>Login..</button>--
>
 </form>
</div>
<div class="form-group-login">
<span class="login">Create Account:</span>
<p class="login" style="padding-left: 10px"><a (click)="singup()">Sign up</a></p>
</div>

</mat-card>

Login.Ts
import {Component, OnInit} from '@angular/core';
import {FormControl, FormGroup, Validators} from '@angular/forms';
import {Router} from '@angular/router';
import {LoginService} from '../service/login.service';

@Component({
selector: 'app-login',
templateUrl: './login.component.html',
styleUrls: ['./login.component.css']
})
export class LoginComponent implements OnInit {
loginForm: FormGroup;
msg = '';
expression = false;
user = {
email: '',
password: ''
};

constructor(private routers: Router, public loginservice: LoginService) {

 this.loginForm = new FormGroup({
email: new FormControl('', [Validators.required, Validators.email]),
password: new FormControl('', [Validators.required])
});
}

ngOnInit(): void {
}

singup() {
this.routers.navigate(['/signup']);
}

onSubmit() {
if (this.loginForm.value.email === 'admin@gmail.com' &&
this.loginForm.value.password === 'admin') {
console.log('admin login successfully');
this.routers.navigate(['/admin']);
}
else {
// this.routers.navigate(['/main']);
console.log(this.loginForm.value.email);
console.log(this.loginForm.value.password);
const logindata = {email: this.loginForm.value.email, password:
this.loginForm.value.password};
this.loginservice.create(logindata).subscribe(data => {
console.log(data);
console.log('LoginSuccessfully');
this.routers.navigate(['/main']);
}, error => {
console.log('exception occured');
 this.msg = 'Plase Enter Your Valid Email And Password';
});
}
}
}

Service and RESTApi Request:

import {HttpClient, HttpHeaders} from '@angular/common/http';
import {Injectable} from '@angular/core';
@Injectable({
providedIn: 'root'
})
export class LoginService {

constructor(private httpClient: HttpClient) {

}

create(logindata: { email: string, password: string }) {

const httpHeaders = new HttpHeaders();
httpHeaders.append('content-type', 'application/json');
return this.httpClient.post('http://localhost:9090/login', logindata, {headers: httpHeaders});
}

signin(signindata: { name: string, email: string, password: string, number: number, country:
string, gender: string }) {
const httpHeader = new HttpHeaders();
httpHeader.append('content-type', 'application/json');
return this.httpClient.post('http://localhost:9090/register', signindata, {headers:
httpHeader});
}}
 BackEnd:
Entity:
Register.java
package com.collegeproject.freelencerapi.entity;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Data
@Table(name = "register")
public class Register {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
private String name;
private String email;
private String password;
private String number;
private String country;
private String gender;
public Register() {

public Register(String name, String email, String password, String number, String country,
String gender) {
super();
this.name = name;
 this.email = email;
this.password = password;
this.number = number;
this.country = country;

this.gender = gender;
}

public int getId() {

return id;
}

public void setId(int id) {

this.id = id;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public String getEmail() {

return email;
}

public void setEmail(String email) {

this.email = email;
}
public String getPassword() {
return password;
}

public void setPassword(String password) {

this.password = password;
}

public String getNumber() {

return number;
}

public void setNumber(String number) {

this.number = number;
}

public String getCountry() {

return country;
}

public void setCountry(String country) {

this.country = country;
}

public String getGender() {

return gender;
}

public void setGender(String gender) {

this.gender = gender;
}}
Repository:
RegistrationRepository.java:
package com.collegeproject.freelencerapi.repository;

import com.collegeproject.freelencerapi.entity.Register;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface RegistrationRepository extends JpaRepository<Register, Integer> {

Register findByEmail(String email);

Register findByEmailAndPassword(String email, String password);

@Query(value = "select * from register ", nativeQuery = true)

public List<Register> getAllBYWork();

}
Service:
RegisterService.java
package com.collegeproject.freelencerapi.service;

import com.collegeproject.freelencerapi.entity.Register;
import com.collegeproject.freelencerapi.repository.RegistrationRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RegistrationService {
@Autowired
public RegistrationRepository registrationRepository;

public Register SaveRegister(Register register) {

return registrationRepository.save(register);
}

public Register fetchUserByEmail(String email) {

return registrationRepository.findByEmail(email);
}

public Register fetchUserByEmailAndPassword(String email, String password) {

return registrationRepository.findByEmailAndPassword(email, password);
}

}
Controller:
RegisterController.java:
package com.collegeproject.freelencerapi.controller;

import com.collegeproject.freelencerapi.entity.Register;
import com.collegeproject.freelencerapi.service.RegistrationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RegistrationController {
@Autowired
private RegistrationService registrationService;

@PostMapping("/register")
public Register saveregister(@RequestBody Register register) throws Exception {
String tempEmail = register.getEmail();
if (tempEmail != null && !"".equals(tempEmail)) {
Register user = registrationService.fetchUserByEmail(tempEmail);
if (user != null) {
throw new Exception("This is Email Id " + tempEmail + "already exist");
}
}

Register userobj = null;

userobj = registrationService.SaveRegister(register);
return userobj;
}
 @PostMapping("/login")
public Register loginUser(@RequestBody Register register) throws Exception {
String tempEmail = register.getEmail();
String tempPassword = register.getPassword();
// String tempacount = register.getAccount_type();

Register userobj = null;

if (tempEmail != null && tempPassword != null) {
userobj = registrationService.fetchUserByEmailAndPassword(tempEmail,
tempPassword);

}
if (userobj == null) {
throw new Exception("Bad credentials");
}

return userobj;
}

}
Screen Layouts:
Main Home:
Register
Login:
Job Post:
Place Bid:
Freelancer Home:
Project List Or Feed:
Overview:
Process:
Admin:
Thank You