Data Bridge – A file transfer website

PROJECT SYNOPSIS
OF MINOR PROJECT

BACHELOR OF TECHNOLOGY
Data Science & VII

SUBMITTED BY
Mohit Kumar
(Roll No:- 2101331540066)

NOIDA INSTITUTE OF ENGINEERING & TECHNOLOGY,

GRATER NOIDA, UTTAR PRADESH
 STUDENT’S DECLARATION

I hereby certify that the work which is being presented in the major project report entitled “Data Bridge ( A File Sharing
Solution )” in fulfillment of the requirement for the award of the Degree of Bachelor of Technology in Department of
Data Science of Noida Institute of Engineering and Technology, Greater Noida, Dr. A.P.J. Abdul Kalam Technical
University (AKTU), Uttar Pradesh is an authentic record of my own work carried out during VII semester.

Date:25/09/2025 Mohit Kumar

The major project viva-voce examination of Mr. Mohit Kumar Roll no. 2101331540066 Of B.TECH ( Data Science)
has been held on 19/11/2024.

Signature of:

Project Guide: _______ Head of Dept:

(Stamp of organization)

External Examiner: _______ Internal Examiner _________

 ACKNOWLEDGEMENT

We are highly grateful to the Dr. Vinod M Kapse, Director, Noida Institute of Engineering and Technology, Greater
Noida, for providing this opportunity.

The constant guidance and encouragement received from Manali Gupta, HOD (Data Science, dept.), NIET, Greater
Noida, has been of great help in carrying out the project work and is acknowledged with reverential thanks.

We would like to express a deep sense of gratitude and thanks profusely to Mr. Sovers Singh Bisht project guide,
without the wise counsel and able guidance, it would have been impossible to complete the report in this manner.

We express gratitude to other faculty members of Data Science department of NIET for their intellectual support
throughout the course of this work.

Finally, the authors are indebted to all whosoever have contributed in this report work.

NAME OF THE STUDENT

Mohit Kumar
Chapter 1- Introduction
1.1 Objective
1.2 Problem definition
1.3 Scope
1.4 Definitions, Acronyms and Abbreviations
1.5 Technologies to be used
Chapter 2- Software Requirement Specifications
2.1 Introduction
2.1.1 Purpose
2.1.2 Project Scope
2.2 Overall Description
2.2.1 Product/Project Perspective
2.2.2 Product/Project Function
2.2.3 User Classes and Characteristics
2.2.4 Operating Environment
2.2.5 Architecture Design

2.2.6 Constraints
2.2.7 Use Case Model Description
2.2.8 Assumptions and Dependencies
2.3 System Features
2.4 External Interface Requirements
2.4.1 User Interfaces
2.4.2 Hardware Interfaces
2.4.3 Software Interfaces
2.4.4 Communications Interfaces
2.5 Other Nonfunctional Requirements
2.5.1 Performance Requirements
2.5.2 Safety Requirements
2.5.3 Security Requirements
2.5.4 Software Quality Attributes

Chapter 3- System Design

3.1 Flowcharts
Chapter 4- Conclusions and future scope
5.1 Conclusion
5.2 Future Scope
Chapter 5- References
Data Bridge – A file transfer website

1. Introduction
1.1 Objective

The primary objective of the Data Bridge project is to develop a secure, scalable, and user-friendly web application for
transferring files. It allows users to upload and download files seamlessly, ensuring data security and usability. The
system leverages Spring Boot for the backend, JSP for dynamic web content, and File.io as an external service for file
storage.

Key objectives include:

 Simple File Sharing: Users can upload files and share a unique key to facilitate downloads.
 Scalability: Support for large file sizes (up to 5GB).
 Security: Proper input validation to prevent misuse.

1.2 Problem Definition

Traditional file transfer systems often have limitations:

 Complex User Interfaces: Existing platforms may not be intuitive for users.
 Size Restrictions: Many platforms impose stringent file size limits.
 Lack of Security: Risk of data breaches or misuse without proper validation.

This project addresses these gaps by providing:

 A lightweight, web-based file sharing system.

 High file size limit (5GB).
 Secure communication with external APIs for file storage and retrieval.

1.3 Scope

The Data Bridge system aims to serve a broad range of users:

 Students and Professionals: For easy file sharing in academic or professional settings.
 Developers: To transfer large datasets or codebases.

Features include:

 Uploading and downloading files via unique keys.

 Intuitive and responsive web interface.
 Backend validation and error handling for seamless operation.
1.4 Definitions, Acronyms, and Abbreviations

1.4 Definitions, Acronyms, and Abbreviations

1. REST: Representational State Transfer – A style for designing networked applications that uses stateless client-
server communication.
2. API: Application Programming Interface – A set of rules that allows different software components to
communicate with each other.
3. MultipartFile: A Spring interface used to represent uploaded files in HTTP requests.
4. HTTP: Hypertext Transfer Protocol – A protocol for sending requests and receiving responses over the web.
5. File.io: A third-party service for temporary file storage, allowing files to be shared via unique keys or URLs.
6. JSON: JavaScript Object Notation – A lightweight data format for exchanging information between the client
and server.
7. HTTP Status Codes:
o 200 OK: Request was successful.
o 400 Bad Request: Client-side error due to invalid request data.
8. MVC: Model-View-Controller – A design pattern used in software development to separate application logic,
user interface, and data management.

1.5 Technologies to Be Used

1. Spring Boot:
o A framework for building robust and production-ready backend applications with minimal configuration.
2. File.io API:
o An external service for storing and retrieving files using unique file keys.
3. Java:
o The core programming language used to develop backend services and logic.
4. RestTemplate:
o A Spring utility to interact with RESTful web services (e.g., File.io API).
5. HTML:
o The markup language used for creating the structure of web pages.
6. Maven:
o A build tool for managing dependencies and automating project builds.
7. Eclipse:
o IDEs used for writing, testing, and debugging the project code.
Chapter 2: Software Requirement Specifications
2.1 Introduction

2.1.1 Purpose

The purpose of the Data Bridge project is to develop a secure, lightweight, and scalable web-based file-sharing
application. This system enables users to upload files, retrieve them using unique keys, and ensure data integrity
throughout the process. The application is intended for users who require quick and secure file transfers without the
complexity of larger file-sharing systems.

2.1.2 Project Scope

The project scope includes:

 Building a web interface for file uploads and downloads.

 Using the File.io API for temporary file storage.
 Supporting file sizes up to 1GB.
 Ensuring secure file transfers with proper error handling and input validation.
 Providing performance metrics and scalability for larger user bases.

Target audience includes students, professionals, and developers requiring secure file-sharing capabilities.

2.2 Overall Description

2.2.1 Product/Project Perspective

The Data Bridge system is a standalone, web-based application designed to facilitate secure file transfers. It operates
within a typical client-server architecture:

 Client: HTML-based web interface.

 Server: Spring Boot backend with RESTful endpoints.
 File Storage: Temporary storage using File.io's external API.

2.2.2 Product/Project Function

Core functionalities include:

1. File Upload: Users can upload files and receive a unique key for retrieval.
2. File Download: Files can be downloaded using the provided key.
3. Error Feedback: Users are notified of any errors, such as invalid keys or upload failures.
4. Logging: The system logs upload and download events for monitoring and debugging.

2.2.3 User Classes and Characteristics

The system is designed for:

 General Users: Require simple, secure file sharing.

 Technical Users: Seek a lightweight solution for transferring large files efficiently.

2.2.4 Operating Environment

 Hardware:
o Any device capable of running a web browser and Java applications.
  Software:
o Java Development Kit (JDK) 11+
o Spring Boot 6.x
o File.io API
o Web browser (Google Chrome, Firefox).

2.2.5 Architecture Design

The system follows a 3-tier architecture:

1. Presentation Layer: HTML for user interaction.

2. Business Logic Layer: Spring Boot for handling file upload/download logic.
3. Data Layer: External file storage using File.io API.

Include a diagram of the system's architecture here.

2.2.6 Constraints

 File size limit of 5GB per upload.

 Internet connectivity is mandatory for API interactions.
 Dependence on File.io's availability and service limits.

2.2.7 Use Case Model Description

Use Case: File Upload and Download

 Actors: User, System, File.io API.

 Scenario: User uploads a file and receives a unique key. Later, the user provides the key to download the file.
 Preconditions: Valid file upload and API availability.
 Postconditions: File successfully uploaded/downloaded.

Include a use case diagram here.

2.2.8 Assumptions and Dependencies

 The system assumes reliable availability of the File.io API.

 Users have access to a stable internet connection.
 Dependencies include Java, Spring Boot, RestTemplate, and File.io API.

2.3 System Features

1. File Upload:
o Users can upload files and receive a unique key for retrieval.
2. File Download:
o Users can download files by entering the unique key.
3. Error Handling:
o Handles errors such as invalid keys, network issues, or file size exceeding the limit.
4. Logging:
o Maintains logs for each operation to ensure traceability.

2.4 External Interface Requirements

2.4.1 User Interfaces

  A simple HTML-based interface for file uploads and downloads.

2.4.2 Hardware Interfaces

 No specialized hardware requirements.

 A standard system with basic computing capabilities.

2.4.3 Software Interfaces

 Java: Backend logic.

 RestTemplate: To make HTTP requests to the File.io API.
 File.io API: For file storage and retrieval.

2.4.4 Communications Interfaces

 The system communicates over HTTP for interacting with File.io's REST API.

2.5 Other Nonfunctional Requirements

2.5.1 Safety Requirements

 Ensures the file storage URL is not exposed to unauthorized users.

 Handles exceptions gracefully to avoid system crashes.

2.5.2 Security Requirements

 Input validation to prevent malicious file uploads.

 Secure communication between the application and File.io API.

2.5.3 Software Quality Attributes

 Maintainability: Well-structured code for easy debugging and enhancements.

 Usability: Simple interface to ensure a smooth user experience.
 Reliability: Consistent performance under varying loads.
 Scalability: Can handle increased traffic with minimal performance impact
Chapter 3- System Design

3.1 Flowchart

1. File Upload Flow:

a. User Input:

 The user navigates to the root page (/) and is presented with a file upload form (HTML).
o They select a file to upload and click the "Upload File" button.

b. HTTP Request:

 The form submits a POST request to the /upload endpoint, with the file sent as part of the request body in the
multipart/form-data format.

c. Controller Handling (FileController):

 The FileController receives the request.

 It checks if the file is empty. If so, it displays an error message.
 Otherwise, it calls the uploadFile() method in the FileService to handle the file upload process.

d. File Upload Logic (FileService):

 File Validation:
o The method checks whether the file is empty or exceeds the max file size (5GB). If either condition is
true, it throws an exception.
 RestTemplate Request:
o A POST request is sent to file.io via RestTemplate. The file is packaged into a MultiValueMap along
with the appropriate headers (Content-Type: multipart/form-data).
 Response Handling:
o If the upload is successful, the response contains a unique key from file.io, which is the identifier for the
uploaded file.
 o The key is returned to the FileController.

e. Controller Response:

 The FileController receives the key and returns it to the view (index.html), displaying it as the
"uploadResult". If the upload fails, an error message is shown.

f. Frontend Display (index.html):

 The page shows the upload result as a code that the user can share to access the file. This is displayed under the
"Send File" section.
 Success or Failure messages are shown in the UI based on the file upload result.

2. File Download Flow:

a. User Input:

 The user enters the file key (received from the upload process) and the original file name in the "Receive File"
section.
 They click the "Download File" button to initiate the download.

b. HTTP Request:

 The form submits a POST request to the /download endpoint with the fileKey and fileName as parameters.

c. Controller Handling (FileController):

 The FileController receives the request.

 It calls the downloadFile() method in FileService to retrieve the file using the provided fileKey.

d. File Download Logic (FileService):

 The downloadFile() method constructs the URL for the file on file.io using the fileKey.
 It sends a GET request to file.io to download the file as a byte array.
 If the file is found, it returns the content as a ByteArrayResource, which is used to create a downloadable file.

e. Controller Response:

 If the download is successful, the file is served as a ResponseEntity with the appropriate headers to force the
browser to download the file (Content-Disposition: attachment).
 If there's an error (e.g., invalid fileKey), it returns a badRequest() status.

f. Frontend Handling:

 If the file download succeeds, the file will be downloaded to the user's machine.
 If the download fails, the user will not get the file, and they may see an error.
Chapter 4: Conclusions and Future Scope

4.1 Conclusions

The Data Bridge project successfully delivers a reliable file transfer system, leveraging Spring Boot, RestTemplate,
and the file.io API. It offers users a simple yet secure platform for uploading and sharing files. The integration with
file.io ensures efficient file storage, while the backend is designed to securely handle data uploads. The system’s web
interface is user-friendly, and error handling is implemented to maintain stability.

Key strengths include the flexibility of file types supported, secure file handling, and smooth communication between
the Spring Boot backend and file.io API. The project meets the initial objectives of file transfer while ensuring security,
ease of use, and reliability.

4.2 Future Scope

While the project is functional, there is considerable scope for expansion:

1. Security Enhancements: Future versions can integrate stronger encryption for data at rest and in transit. User
authentication systems (e.g., JWT, OAuth) could enhance access control, securing file uploads and downloads.
2. Scalability: As usage grows, migrating to cloud storage solutions like AWS S3 and implementing load
balancing could support increased traffic and improve reliability.
3. User Features: Additional features such as file versioning, previews, and search would improve the user
experience and provide more control over uploaded files.
4. Performance Improvements: Faster upload and download speeds can be achieved by integrating file
compression and chunked uploads for large files, optimizing transfer times.
5. Service Integration: The system can be expanded to support cloud services like Google Drive, Dropbox, and
OneDrive, offering more options for users.
6. Mobile Application: A mobile app would increase accessibility, allowing users to upload and manage files from
smartphones, potentially with push notifications for successful uploads.
7. Advanced File Management: Future versions could introduce features like file categorization, tagging, and
custom metadata, aiding users in better organizing and managing large amounts of data.
Chapter 5: References

1. Deck, P. (n.d.). Spring MVC: A Tutorial. [Online] Available at: https://www.springmvc-tutorial.com

2. GeeksforGeeks. (2020). File Transfer Using TCP Socket in Python. [Online] Available at:
https://www.geeksforgeeks.org/file-transfer-using-tcp-socket-in-python/
3. Telusko. (2021). Spring Boot Tutorial for Beginners. [YouTube Video]. Available at:
https://www.youtube.com/@Telusko