Summer Internship at RDSO (Ministry of Railways,

Government of India)

An Industrial Internship Report

submitted by

KARAN VERMA

(21BCI0211)

in partial fulfilment for the award of the degree of

BACHELOR OF TECHNOLOGY

in

COMPUTER SCIENCE ENGINEERING WITH SPECIALIZATION IN

INFORMATION SECURITY

SCHOOL OF COMPUTER SCIENCE AND ENGINEERING

MARCH 2024

-1-
 DECLARATION BY THE CANDIDATE

I hereby declare that the Industrial Internship report entitled “Summer

Internship at RDSO” submitted by me to Vellore Institute of Technology,
Vellore in partial fulfilment of the requirement for the award of the degree of
Bachelor of technology in Computer Science Engineering with Specialization
in Information Security is a record of bonafide industrial training undertaken by
me under the supervision of Anubhav Agrawal , Director, RDSO (Ministry of
Railways) . I further declare that the work reported in this report has not been
submitted and will not be submitted, either in part or in full, for the award of any
other degree or diploma in this institute or any other institute or university.

Signature of the student

Name: Karan Verma

Reg. Number: 21BCI0211

-2-
 School of Computer Science and Engineering

BONAFIDE CERTIFICATE

This is to certify that the Industrial Internship report entitled “Summer

Internship at RDSO” submitted by Karan Verma(21BCI0211) to Vellore
Institute of Technology, Vellore in partial fulfilment of the requirement for the
award of the degree of Bachelor of technology in Computer Science
Engineering with Specialization in Information Security is a record of
bonafide Industrial Internship undertaken by him/her under my supervision. The
training fulfils the requirements as per the regulations of this Institute and in my
opinion, meets the necessary standards for submission. The contents of this report
have not been submitted and will not be submitted either in part or in full, for the
award of any other degree or diploma in this institute or any other institute or
university.

Signature of the Supervisor

SUPERVISOR

Date: Date:

Internal Examiner (s) External Examiner (s)

-3-
-4-
 ACKNOWLEDGEMENT

I am deeply grateful to the Research Designs and Standards Organization

(RDSO), Lucknow, a prestigious institution operating under the aegis of the
esteemed Railway Ministry of India, for extending to me the opportunity to
participate in an enriching summer training program. I wish to express my
profound appreciation to Mr. Singhasan Prasad sir for his mentorship and expert
guidance throughout the duration of my training. His insights and encouragement
have significantly broadened my comprehension of the intricate workings within
the domain of railway systems.

The collective support and cooperation extended by the entire RDSO team were
pivotal in enhancing my practical understanding and refining my skill set in this
specialized field. Their readiness to impart knowledge and offer assistance has
been instrumental in my learning journey. I am indebted to RDSO for entrusting
me with substantial projects, allowing me to gain practical experience that
supplements academic knowledge.

This training period stands as a cornerstone in my academic and professional

growth, and I extend my heartfelt gratitude to RDSO and Mr. Singhasan Prasad
sir for their unwavering support and guidance.

Place : Vellore
Karan Verma
Date : 03/05/2024

-5-
 TABLE OF CONTENTS

CHAPTER NO. TITLE PAGE NO.

1. INTRODUCTION 8-15
1.1 Internship Introduction 8-10
1.1.1 Company Background 9
1.1.2 Project Goals 9-10
1.2 Project Background 10-11
1.2.1 Research Designs and Standards Organization
11
(RDSO)
1.2.2 Django Applications 11
1.3 Project Requirements 11-13
1.3.1 Coach Data Requirements 12
1.3.2 Brake Distance Calculation Requirements 13
1.4 Development Approach 13-15
1.4.1 Methodology 14
1.4.2 Tools and Technologies 14-15
DATABASE DESIGN AND BACKEND
2. 15-21
DEVELOPMENT
2.1 Database Design 15-17
2.1.1 Database Selection 16
2.1.2 Table Design 16-17
2.2 Data Modeling 17-18
2.2.1 Django Models 17-18
2.2.2 Relationships and Normalization 18
2.3 Backend Development 18-19
2.3.1 Core Functionalities 19
2.3.2 Unit Testing 19
2.4 Additional Features 20-21
2.4.1 Search and Filtering 20
2.4.2 User Authentication and Authorization 20-21
FRONTEND DEVELOPMENT AND
3 21-25
INTEGRATION

-6-
 3.1 User Interface Design 21-22
3.1.1 UI/UX Principles 21
3.1.2 Wireframing and Prototyping 22
3.2 Frontend Development 22-23
3.2.1 HTML Structure 23
3.2.2 CSS Styling and Animations 23
3.3 Backend-Frontend Integration 23-24
3.3.1 API Endpoints 24
3.3.2 Data Exchange 24
3.4 Interactive Features 24-25
3.4.1 Data Entry Forms 25
3.4.2 Data Visualization 25
4 TESTING AND OPTIMIZATION 26
4.1 Testing Strategies 26-28
4.1.1 Integration Testing 26
4.1.2 User Acceptance Testing 27-28
4.2 Performance Optimization 28-30
4.2.1 Database Indexing 29
4.2.2 Front-end Optimization 29-30
4.3 Documentation and Knowledge Transfer 30-32
4.3.1 Code Documentation 31
4.3.2 User Guides and Training Materials 31-32
5 Appendices 32-44

-7-
1. INTRODUCTION AND PROJECT OVERVIEW

1.1 Internship Introduction

The summer internship at the Research Designs and Standards Organization (RDSO) was not
just a stint in a prestigious institution; it was a gateway to a world of practical learning and
professional development. Within the corridors of RDSO, I found myself immersed in the
realm of railway technology and software development, confronting real-world challenges
and contributing to meaningful solutions. This experience was more than just a line on my
resume; it was a transformative journey that shaped my understanding of the intricate
workings of the railway industry.

At the heart of this internship was the opportunity for personal growth. As a student, I had
amassed a wealth of theoretical knowledge, but it was within the dynamic environment of
RDSO that I could truly put that knowledge into practice. Every day presented new
challenges, from grappling with complex algorithms to navigating the nuances of web
development. Yet, it was precisely these challenges that fueled my growth, pushing me to
expand my skill set and broaden my horizons.

Central to my internship experience were the two Django applications I had the privilege to
work on. These applications were not just lines of code; they were tangible solutions to real-
world problems faced by the Indian Railways organization. The first application focused on
streamlining the management of coach data, providing a centralized platform for storing and
analyzing crucial information. Meanwhile, the second application tackled the critical task of
emergency brake distance calculations, leveraging sophisticated algorithms to ensure the
safety and efficiency of railway operations.

Through these projects, I gained invaluable insights into the pivotal role of software solutions
in the railway industry. I saw firsthand how technology could revolutionize age-old processes,
enhancing efficiency, and safety in equal measure. But perhaps more importantly, I learned
the power of collaboration and innovation in driving meaningful change. Working alongside
seasoned professionals at RDSO, I was inspired by their dedication and expertise, and I

-8-
emerged from this internship with a newfound passion for leveraging technology to solve
real-world challenges.

1.1.1 Company Background

The Research Designs and Standards Organization (RDSO) stands as a beacon of innovation
within India's railway landscape, operating under the Ministry of Railways. Since its
inception, RDSO has been instrumental in driving technological advancements and
establishing standards that shape the country's extensive railway network. Positioned as a
premier institution, RDSO's mandate extends beyond mere research; it is a catalyst for
transformation, constantly pushing the boundaries of what's possible in railway technology.
Through cutting-edge research initiatives and the formulation of design guidelines, RDSO has
cemented its reputation as a trusted authority in the realm of railway innovation.

RDSO's commitment to excellence is reflected in its dedicated team of experts and state-of-
the-art facilities. Beyond research, the organization is deeply invested in enhancing railway
technology, infrastructure, and operations. Through a holistic approach that includes rigorous
testing, innovative design solutions, and the development of cutting-edge technologies, RDSO
addresses the evolving needs of India's ever-expanding railway network. Importantly, RDSO's
influence transcends national borders, garnering respect and recognition on the global stage.
Its contributions to the railway research and standards community serve as a testament to
India's prowess in technological innovation and infrastructure development.

1.1.2 Project Goals

The internship project embarked upon a mission to develop two Django applications tailored
specifically for RDSO's needs. The primary objective was to streamline and optimize the
management of coach data and emergency brake distance calculations. These applications
weren't just about digitizing existing processes; they aimed to revolutionize the way RDSO
handled critical aspects of railway operations. The focus was on providing a comprehensive
solution for managing coach information, encompassing details such as type, number, speed,
and grade. Additionally, the applications were tasked with incorporating complex algorithms

-9-
to accurately calculate emergency brake distances based on predefined formulas and relevant
specifications.

Beyond functionality, the project also prioritized user experience, aiming to create a user-
friendly interface that would empower stakeholders with deeper insights into coach
performance and braking dynamics. Through effective data visualization and analysis tools,
decision-makers within RDSO would be equipped to make informed choices that enhance
railway safety and efficiency. Leveraging the robust framework of Django and integrating
sophisticated data processing modules, the applications sought to elevate the standard of
railway operations by providing decision-makers with accurate, accessible, and actionable
information. Ultimately, the project's goals aligned with RDSO's overarching mission of
driving innovation and setting standards that propel India's railway network into the future.

1.2 Project Background

The Research Designs and Standards Organization (RDSO), a prestigious institution

operating under the aegis of the esteemed Railway Ministry of India, has long been at the
forefront of driving innovation and setting standards within the railway domain. With a rich
history and a commitment to excellence, RDSO has consistently embraced cutting-edge
technologies to address the evolving needs of the country's vast railway network.

The project's genesis stemmed from the organization's continuous pursuit of safety and
efficiency in railway operations. By harnessing the power of modern web technologies and
leveraging the capabilities of the Django framework, RDSO sought to develop a
comprehensive solution that would revolutionize the management of coach data and
emergency brake distance calculations. This ambitious endeavor aimed to empower
stakeholders with accurate and actionable information, ultimately contributing to the
enhancement of railway safety protocols and decision-making processes.

- 10 -
1.2.1 Research Designs and Standards Organization (RDSO)

Established as a premier research and development institution under the Railway Ministry of
India, the Research Designs and Standards Organization (RDSO) in Lucknow stands as a
beacon of excellence in the realm of railway technology. Tasked with the crucial
responsibility of formulating and implementing design standards for Indian Railways, RDSO
plays a pivotal role in ensuring the safety, efficiency, and innovation of the country's vast
railway network.

At the heart of RDSO's mission is the commitment to continually enhance railway

technology, infrastructure, and operations. The organization's multifaceted approach
encompasses rigorous testing, innovative design solutions, and the development of cutting-
edge technologies to meet the dynamic needs of India's ever-expanding railway network. As a
center of excellence, RDSO's contributions extend beyond national boundaries, positioning it
as a respected entity in the global railway research and standards community.

1.2.2 Django Applications

The internship project focused on the development of two distinct yet interconnected Django
applications tailored to address the specific needs of RDSO. These applications aimed to
revolutionize the management of coach data and emergency brake distance calculations,
leveraging the power and flexibility of the Django web framework.

The first application was designed to facilitate the storage, retrieval, and management of
comprehensive coach information, including details such as coach type, number, speed, and
grade. This application served as a centralized repository, enabling stakeholders to access and
analyze critical data related to the vast fleet of coaches operating within the Indian Railways
network.

1.3 Project Requirements

The success of any software development project hinges on a thorough understanding of the
requirements, and the Django applications for RDSO were no exception. A meticulous

- 11 -
requirements gathering process was undertaken, involving extensive consultations with
stakeholders, subject matter experts, and end-users within RDSO. This collaborative approach
ensured that the development team had a comprehensive understanding of the specific needs
and expectations for each application. By actively engaging with diverse groups, potential
blind spots were minimized, and a shared vision for the project was established.

The requirements gathering phase served as the cornerstone for shaping the project's roadmap
and defining the functionalities that would be incorporated into the applications. This
involved a granular examination of the functionalities required for both the coach data
management and emergency brake distance calculation aspects of the project. Key
considerations included identifying the data points necessary for coach information, defining
the formulas and algorithms for emergency brake distance calculations, and determining the
desired features for the user interface and data visualization components.

1.3.1 Coach Data Requirements

Managing coach data was identified as one of the primary components of the project, given its
critical role in railway operations. Through extensive discussions and consultations, a detailed
set of requirements was established to ensure that the Django application could efficiently
handle the storage, retrieval, and analysis of coach-related data. This process involved not
only identifying the types of data to be captured but also determining the optimal structure for
storing and organizing this information within the application.

The specific requirements for managing coach data encompassed a wide range of details,
including coach type, unique identification numbers, maximum speed capabilities, and track
grade specifications. Additionally, stakeholders emphasized the need for robust search and
filtering functionalities to enable users to quickly locate specific coach information based on
various criteria. By addressing these requirements, the application aimed to provide a
comprehensive and user-friendly solution for managing and analyzing coach data, ultimately
supporting informed decision-making processes within RDSO.

- 12 -
1.3.2 Brake Distance Calculation Requirements

Ensuring the safety of railway operations was identified as a paramount concern for RDSO,
underscoring the importance of accurate emergency brake distance calculations. The
requirements gathering process focused extensively on defining the specific parameters and
algorithms needed to compute these critical calculations within the Django application. This
involved collaborating closely with stakeholders to understand the intricacies of brake
distance calculations and identify the key factors that needed to be considered.

Key requirements for brake distance calculations included the ability to input relevant coach
specifications, such as speed, weight, and braking system characteristics, as well as factors
related to track conditions and environmental variables. The application was expected to
incorporate complex mathematical formulas and algorithms to accurately determine the
emergency brake distance based on these inputs. Additionally, stakeholders emphasized the
need for user-friendly interfaces and data visualization tools to interpret and analyze the
calculated brake distances, enabling informed decision-making and the implementation of
appropriate safety measures. By addressing these requirements, the application aimed to
enhance the safety and efficiency of railway operations, aligning closely with RDSO's
overarching mission.

1.4 Development Approach

The successful delivery of the Django applications for RDSO necessitated a structured and
methodical development approach. Recognizing the complexity of the project and the
stringent requirements set forth by RDSO, the development team adopted a systematic
strategy. This approach was characterized by meticulous planning, iterative development
cycles, and a steadfast commitment to adhering to industry best practices and standards. By
laying a solid foundation and setting clear expectations from the outset, the team aimed to
ensure the quality and timely delivery of the applications.

Embracing an agile methodology was instrumental in navigating the complexities of the

project and fostering collaboration with stakeholders. Specifically, the development team
adopted the Scrum framework, which emphasizes iterative and incremental development.

- 13 -
This approach facilitated frequent interaction with stakeholders, enabling rapid adaptation to
changing requirements and prioritizing the delivery of high-value features. Through regular
sprint planning, daily stand-ups, and retrospective meetings, the team ensured transparency,
effective communication, and continuous improvement throughout the project's lifecycle. By
embracing agility, the team remained responsive to evolving needs and maintained a focus on
delivering maximum value to RDSO.

1.4.1 Methodology

The adoption of an agile methodology, particularly the Scrum framework, provided a

structured framework for streamlining the development process. Scrum's iterative and
incremental approach enabled the development team to break down the project into
manageable chunks, known as sprints, and deliver working software at the end of each
iteration. This flexibility allowed the team to adapt to changing requirements and rapidly
respond to feedback from stakeholders and end-users, ensuring that the final deliverables met
RDSO's evolving needs effectively.

Agile methodologies fostered a culture of continuous improvement within the development

team. Regular sprint retrospectives provided valuable opportunities for reflection, allowing
team members to assess their processes, identify areas for optimization, and implement
necessary adjustments. By embracing feedback and iterating on their approach, the team was
able to enhance efficiency, productivity, and overall project success. Additionally, the use of
agile practices such as user story mapping and prioritization ensured that development efforts
remained aligned with the project's goals and stakeholder needs, maximizing the value
delivered at every stage of the project.

1.4.2 Tools and Technologies:

A carefully curated suite of tools and technologies formed the backbone of the development
process, ensuring the successful delivery of the Django applications. At the core of the project
was the Django web framework, renowned for its robust features, scalability, and extensive

- 14 -
community support. Leveraging Django's versatility, the development team was able to build
robust, feature-rich applications that met RDSO's requirements effectively.
Complementing Django, the project utilized PostgreSQL as the relational database
management system. PostgreSQL's robustness and reliability made it an ideal choice for
handling the complex data requirements of the applications. By leveraging the capabilities of
PostgreSQL, the development team ensured that the applications were equipped to handle
large volumes of data efficiently while maintaining data integrity and security. These tools
and technologies formed the foundation upon which the Django applications were built,
enabling the team to deliver high-quality, scalable solutions that met RDSO's exacting
standards.

2.DATABASE DESIGN AND BACKEND DEVELOPMENT

2.1 Database Design

The database design phase served as the bedrock upon which the entire project rested,
defining how data would be stored, retrieved, and managed within the system. This critical
stage involved a thorough examination of the project's requirements, data relationships, and
performance considerations to ensure the creation of a robust and scalable database
architecture. By meticulously analyzing these factors, the development team aimed to lay a
solid foundation that would support the application's functionality and performance
requirements.

At the outset of the database design process, a comprehensive study was conducted to
understand the various data entities involved in the project. This included entities such as
coach information, brake distance calculations, and associated metadata. By gaining a deep
understanding of these entities and their relationships, the team was able to identify key
attributes, relationships, and constraints that would guide the design of the database schema.

- 15 -
This analysis informed decisions regarding table structures, data types, and normalization
strategies, ensuring that the database architecture was well-suited to the project's needs.

2.1.1 Database Selection:

The selection of the appropriate database management system (DBMS) was a pivotal decision
that significantly impacted the project's performance, scalability, and maintainability. After
thorough evaluation of various options, PostgreSQL was chosen as the preferred platform for
its robust features, reliability, and seamless integration with the Django web framework. This
decision was informed by PostgreSQL's reputation as a leading open-source relational
database management system (RDBMS) known for its performance, scalability, and extensive
feature set.

PostgreSQL's strengths as a powerful and feature-rich RDBMS made it an ideal choice for the
project. Its support for advanced data types, efficient indexing mechanisms, and robust
transaction management capabilities ensured efficient data storage and retrieval, even with
large and complex datasets. Additionally, PostgreSQL's seamless integration with Django
provided a streamlined development experience, allowing the team to leverage the full
capabilities of both technologies to build a robust and scalable application.

2.1.2 Table Design:

The table design phase involved translating the identified data entities and relationships into a
well-structured database schema. This process required a deep understanding of data
normalization principles, which aim to minimize redundancy and ensure data integrity within
the database. By adhering to these principles, the development team aimed to create a
database schema that was efficient, scalable, and easy to maintain.

Through meticulous analysis, tables were carefully designed to represent the various aspects
of coach data and brake distance calculations. This included creating tables to store coach
types, specifications, and associated metadata, as well as dedicated tables for emergency
brake distance calculations and related parameters. By properly organizing the database

- 16 -
schema and separating concerns into distinct tables, the team ensured efficient data access and
manipulation, laying the groundwork for a robust and scalable application.

2.2 Data Modeling

Data modeling served as a crucial link between the database design and the Django web
application. This phase was pivotal in creating Django models, which acted as abstractions of
the underlying database tables, facilitating seamless interaction between the application logic
and the persistent data storage. By meticulously crafting these models, the development team
ensured that the application could effectively manipulate and manage data in alignment with
the project's requirements.

Leveraging Django's robust Object-Relational Mapping (ORM) capabilities, the data

modeling process involved defining models as Python classes with attributes representing the
database fields. These models not only facilitated data manipulation but also encapsulated
business logic, validation rules, and relationships between different data entities. This
approach provided a clear and intuitive representation of the underlying data structure,
enabling developers to focus on building application logic without being burdened by low-
level database interactions.

2.2.1 Django Models

Django's model system offered a powerful framework for defining data models that directly
corresponded to the underlying database tables. Each model represented a specific data entity,
such as coach types, specifications, or brake distance calculations, with attributes
corresponding to the respective database fields. This alignment between models and database
tables streamlined data manipulation and ensured consistency between the application's data
layer and the underlying database schema.

A significant advantage of Django's models lay in their ability to define relationships between
different data entities. These relationships, ranging from one-to-one to many-to-many, were

- 17 -
seamlessly translated into database-level constraints and foreign key references. This
approach ensured data integrity and facilitated efficient querying and manipulation of related
data, empowering developers to build complex and interconnected data structures with ease.

2.2.2 Relationships and Normalization

Data integrity and minimizing redundancy were paramount considerations during the data
modeling phase. To achieve these goals, the team rigorously applied the principles of database
normalization, resulting in a well-structured and efficient database schema. By identifying and
analyzing the relationships between different data entities, such as coach types, specifications,
and brake distance calculations, the team implemented appropriate normalization strategies.

This involved breaking down data into logically distinct tables and establishing relationships
through foreign key constraints. By adhering to normalization principles, the team ensured
data consistency and eliminated redundancy, leading to a more efficient and maintainable
database schema. These efforts laid the groundwork for a robust and scalable data model,
capable of supporting the application's functionality and performance requirements.

2.3 Backend Development

The backend development phase focused on implementing the core functionalities of the
Django applications, including the management of coach data and the calculation of
emergency brake distances. This phase leveraged the power and flexibility of the Django web
framework, combined with Python's robust capabilities for data processing and mathematical
computations.

Throughout this phase, the backend development team worked closely with stakeholders and
subject matter experts to ensure that the implemented functionalities accurately reflected the
requirements and adhered to industry best practices. Rigorous coding standards, version

- 18 -
control, and collaborative development practices were employed to maintain code quality and
facilitate seamless collaboration among team members.

2.3.1 Core Functionalities

The core functionalities of the backend development effort revolved around the fundamental
tasks of managing coach data and performing emergency brake distance calculations. These
functionalities encompassed the entire spectrum of CRUD (Create, Read, Update, Delete)
operations for coach entries within the database. Additionally, the implementation integrated
complex mathematical algorithms for calculating brake distances based on predefined
formulas and relevant coach specifications.

Python's versatility and rich ecosystem of libraries played a crucial role in this phase. The
team leveraged Django's built-in capabilities for handling HTTP requests, processing form
data, and interacting with the database through the ORM. Moreover, specialized libraries for
scientific computing and numerical analysis were employed to implement intricate brake
distance calculation algorithms, ensuring accuracy and computational efficiency.

2.3.2 Unit Testing

Ensuring the reliability and correctness of the backend functionalities was paramount
throughout the development process. To achieve this, the team adopted a comprehensive unit
testing strategy, leveraging Django's built-in testing framework and industry-standard testing
practices.

Meticulously designed unit tests covered a wide range of scenarios and edge cases, isolating
individual components of the backend code for thorough validation. These tests not only
verified the correctness of the implemented functionalities but also served as a safety net
against regressions introduced during future code changes or enhancements.

- 19 -
2.4 Additional Features:

While the core functionalities of coach data management and brake distance calculations
formed the foundation of the Django applications, the development team recognized the
importance of providing additional features to enhance usability and meet the diverse needs of
stakeholders.

These additional features included robust search and filtering capabilities, allowing users to
easily locate specific coach data based on various criteria. Comprehensive user authentication
and authorization mechanisms were also implemented to ensure secure access and data
protection, safeguarding sensitive information from unauthorized access.

2.4.1 Search and Filtering:

To facilitate efficient data retrieval and analysis, the backend development team implemented
advanced search and filtering capabilities. These features enabled users to query the coach
data and brake distance calculations based on specific parameters, such as coach type, speed
range, or track grade.

Leveraging Django's powerful ORM and querying capabilities, the search and filtering
functionalities allowed for the construction and execution of complex queries efficiently.
Additionally, the team explored indexing strategies and performance optimization techniques
to ensure that these operations remained responsive, even when dealing with large datasets.

2.4.2 User Authentication and Authorization:

Ensuring the security and integrity of the Django applications was a critical concern,
particularly given the sensitive nature of the data involved. To address this, the backend
development team implemented robust user authentication and authorization mechanisms,
leveraging Django's built-in security features and industry best practices.

- 20 -
User authentication involved securely validating user credentials and managing user sessions,
while authorization mechanisms controlled access to specific functionalities and data based on
predefined roles and permissions. These security measures not only protected sensitive data
from unauthorized access but also enabled fine-grained control over user actions, ensuring
compliance with organizational policies and regulatory requirements.

3.FRONTEND DEVELOPMENT AND INTEGRATION

3.1 User Interface Design

User interface (UI) design is foundational to creating digital products that are effective and
engaging. It involves meticulous planning to ensure the interface is intuitive, visually
appealing, and user-friendly. A well-designed UI significantly impacts the overall user
experience, leading to increased satisfaction, productivity, and adoption of the product.

The UI design process typically begins with comprehensive research and analysis, gathering
insights into user needs, behaviors, and preferences. These insights inform design decisions
regarding layout, navigation, and visual elements. Iterative prototyping and user testing are
integral steps in refining the design, allowing for continuous improvement based on user
feedback.

3.1.1 UI/UX Principles

UI/UX principles are the foundational guidelines governing the design and development of
user interfaces. They ensure interfaces are not only visually appealing but also highly usable
and accessible. Principles such as consistency, simplicity, feedback, and accessibility are
crucial. Consistency maintains a uniform look and behavior across the interface, fostering
familiarity and ease of use.

- 21 -
Simplicity focuses on minimizing complexity and cognitive load, ensuring clarity and focus
in the interface. Feedback provides users with appropriate responses, reinforcing their actions

and promoting a sense of control. Accessibility ensures interfaces can be used by people with
diverse abilities, guaranteeing equal access and usability for all users.

3.1.2 Wireframing and Prototyping

Wireframing and prototyping are fundamental techniques used in UI/UX design. Wireframes
are low-fidelity representations of the interface, serving as blueprints for the final design.
They allow for exploration of various UI concepts and user flows without significant resource
investment.

Prototyping involves creating interactive models of the interface, ranging from low-fidelity
wireframes to high-fidelity simulations. Prototypes enable designers to test design
assumptions, gather user feedback, and iterate on the design before final implementation.
Both wireframing and prototyping are crucial for identifying and addressing usability issues
early on, leading to user-centric designs.

3.2 Frontend Development

Frontend development entails creating and implementing the user-facing components of a

web application or website. It involves using various technologies and languages to build
visually and interactively engaging elements that users directly interact with.

Frontend development encompasses tasks such as structuring and styling web pages using
HTML, CSS, and JavaScript, implementing interactive features and dynamic behavior,
optimizing performance and accessibility, and integrating with backend systems and APIs. It

- 22 -
requires a deep understanding of web standards, best practices, and emerging technologies to
deliver high-quality, responsive, and user-friendly interfaces.

3.2.1 HTML Structure

HTML (Hypertext Markup Language) provides the structure and semantics for creating web
pages. It employs a hierarchical system of elements, each with a defined purpose and
meaning, represented by tags that enclose content.

A well-structured HTML document follows a logical hierarchy, aiding content rendering,

search engine optimization (SEO), and accessibility. By adhering to best practices and
semantic markup, developers create pages easily understood by both browsers and search
engines, improving the overall user experience.

3.2.2 CSS Styling and Animations

CSS (Cascading Style Sheets) governs the visual presentation of HTML elements on web
pages, allowing control over layout, typography, colors, and animations. It separates
presentation from content, promoting code maintainability.

CSS animations bring web pages to life, creating transitions, hover effects, or interactive
sequences. Used judiciously, they enhance user interfaces, capturing attention and conveying
information effectively. Balancing aesthetics and performance ensures smooth user
experiences across devices and browsers.

3.3 Backend-Frontend Integration

Backend-frontend integration connects user-facing frontend components with backend

systems managing data processing, storage, and business logic. This integration enables
dynamic, interactive applications responding to user actions and delivering real-time updates.

- 23 -
It utilizes APIs as communication channels between frontend and backend, adhering to REST
principles for standardized and scalable web services. Effective integration ensures seamless
data exchange, efficient handling of user interactions, and consistent user experiences.

3.3.1 API Endpoints

API endpoints define communication channels between frontend applications and backend
systems, specifying URLs or routes for data retrieval, updating, or manipulation. They
facilitate data exchange, acting as gateways between frontend and backend components.

Well-designed API endpoints follow REST principles, each handling specific operations like
data retrieval (GET), creation (POST), updating (PUT or PATCH), or deletion (DELETE).
Proper implementation ensures secure and efficient communication, enabling seamless
integration and data exchange.

3.3.2 Data Exchange

Data exchange transfers information between frontend user interfaces and backend systems
managing data. It ensures seamless communication, accurately reflecting user interactions and
updates on the frontend.

Common formats like JSON and XML facilitate structured data exchange, with JSON being
prevalent for its lightweight and easy parsing. APIs return data in JSON, easily consumed and
rendered on the frontend, ensuring interoperability and efficient communication. Proper
handling guarantees data integrity, security, and efficient communication between frontend
and backend.

3.4 User Interaction

- 24 -
User interaction refers to the ways users engage with the interface and perform actions to
accomplish tasks or access information. It encompasses various input methods, such as
clicking, typing, dragging, and gestures, as well as feedback mechanisms to indicate system
response.

Effective user interaction design focuses on providing intuitive and responsive interfaces that
guide users through workflows and actions. It includes considerations for input validation,
error handling, feedback messages, and confirmation dialogs to enhance user understanding
and confidence in their interactions.

3.4.1 Data Entry Forms

Data entry forms are essential components of web applications, allowing users to input and
submit data. They vary from simple contact forms to complex multi-step forms with various
input fields and validation requirements.

Well-designed data entry forms employ clear labeling, logical grouping, and intuitive error
handling to streamline the input process and minimize user errors. Features like auto-save,
suggestions, and progress indicators further enhance the user experience, reducing cognitive
load and providing feedback.

3.4.2 Data Visualization

Data visualization transforms raw data into visual representations, such as charts, graphs, and
infographics, to facilitate understanding and communication. It leverages visual cues to
highlight patterns, trends, and insights within the data.

Frontend development incorporates specialized libraries or frameworks for data visualization,

offering customizable options and support for various data formats. These libraries, like D3.js

- 25 -
or Chart.js, enable the creation of interactive and dynamic visualizations, enhancing user
exploration and analysis of data in intuitive and engaging ways.

4.TESTING AND OPTIMIZATION

4.1 Testing Strategies

Testing strategies serve as the cornerstone for ensuring the quality, reliability, and
functionality of software applications. They represent a structured and systematic approach to
identifying, assessing, and rectifying potential issues, bugs, and vulnerabilities before the
application is deployed to end-users. Effective testing strategies not only aid in detecting and
resolving defects but also play a pivotal role in validating that the application aligns
seamlessly with the specified requirements and user expectations, ultimately contributing to
overall user satisfaction and trust in the product's reliability.

Within the realm of testing strategies, there exists a diverse array of methodologies, each
serving a specific purpose and targeting different facets of the application's functionality and
performance. These methodologies include but are not limited to unit testing, integration
testing, system testing, and acceptance testing. Unit testing focuses on testing individual units
or components of the application in isolation, verifying their correctness and functionality.
Integration testing, on the other hand, delves into verifying the interactions and
communication between different components or modules of the application, ensuring they
function harmoniously when integrated. System testing evaluates the application as a whole,
testing its behavior and functionality in a simulated environment resembling the production
environment. Lastly, acceptance testing involves assessing the application from the end-user's
perspective, ensuring it meets the specified requirements, business objectives, and user
expectations before it is officially released for use.

- 26 -
4.1.1 Integration Testing

Integration testing stands as a critical phase in the testing lifecycle, focusing primarily on
verifying the seamless interaction and communication between various components or
modules of an application. It occurs subsequent to the individual testing of units or
components, ensuring they operate cohesively and efficiently when integrated with one
another. This phase of testing serves as a pivotal bridge between unit testing and system
testing, validating the interoperability and compatibility of different components, and
identifying any potential issues or discrepancies that may arise during the integration process.

The execution of integration testing can take on various approaches, with each approach
offering its unique advantages and insights into the application's behavior and performance.
The bottom-up approach involves testing lower-level components first and gradually
integrating them with higher-level components, ensuring a systematic and incremental
integration process. Conversely, the top-down approach initiates testing with higher-level
components and sequentially integrates lower-level components, providing early insights into
the application's overall functionality and behavior. Additionally, the big-bang approach
involves testing all components together simultaneously, offering a holistic view of the
application's performance but potentially posing challenges in isolating and debugging issues.
Effective integration testing facilitates the identification of issues related to data flow,
interfaces, and dependencies between components, ensuring the application operates
seamlessly as an integrated whole.

4.1.2 User Acceptance Testing

User Acceptance Testing (UAT) represents a pivotal phase in the software development
lifecycle, focusing on evaluating the application from the end-user's perspective. This phase
typically occurs subsequent to functional testing and aims to ensure the application aligns
seamlessly with the specified requirements, business objectives, and user expectations before

- 27 -
it is officially deployed for widespread use. User acceptance testing serves as a crucial
checkpoint, validating that the application meets the desired standards of usability,
functionality, and performance, ultimately contributing to user satisfaction and confidence in
the product.

During the user acceptance testing phase, end-users or representatives from the user
community are actively involved in evaluating the application within real-world or simulated
environments, mirroring actual usage scenarios. They rigorously test the application's
functionality, usability, performance, and overall user experience, providing valuable
feedback and insights into any remaining issues or inconsistencies. User acceptance testing
serves as a final opportunity to identify and rectify any discrepancies or deviations from the
expected behavior before the application is officially released for production use. By actively
involving end-users in the testing process, user acceptance testing fosters user acceptance and
confidence in the application, reducing the risk of post-deployment issues or rework and
ultimately contributing to the success of the product.

4.2 Performance Optimization

Performance optimization stands as a critical endeavor in the development process, aimed at

enhancing the speed, efficiency, and responsiveness of an application or system. It
encompasses a series of strategic measures designed to identify and address performance
bottlenecks, optimize resource utilization, and ensure that the application delivers a smooth
and seamless user experience, even under conditions of high load or resource-intensive
operations. By prioritizing performance optimization, developers can significantly enhance
user satisfaction, reduce operational costs, and ensure the scalability and viability of the
application in diverse usage scenarios.

Achieving effective performance optimization necessitates the employment of a diverse array

of techniques and strategies tailored to the specific requirements and characteristics of the
application. These techniques may include but are not limited to code optimization, database
indexing, caching mechanisms, load balancing, infrastructure scaling, and performance

- 28 -
monitoring. Additionally, the utilization of performance analysis tools and profiling
techniques can provide valuable insights into the application's performance characteristics,
enabling developers to pinpoint areas for optimization and implement targeted improvements.
By adopting a proactive approach to performance optimization, developers can ensure that the
application delivers optimal performance across a variety of usage scenarios, ultimately
enhancing user satisfaction and driving the success of the product.

4.2.1 Database Indexing

Database indexing represents a fundamental performance optimization technique employed to

enhance the efficiency and responsiveness of data retrieval operations within an application. It
involves the creation of indexes on database tables, facilitating expedited data access and
retrieval by enabling the database management system (DBMS) to quickly locate and retrieve
data based on the indexed columns. Through strategic indexing, developers can significantly
improve query performance, particularly for operations involving large datasets or complex
search conditions, ultimately enhancing the overall responsiveness and user experience of the
application.

Effective database indexing requires a thoughtful and strategic approach to index creation,
taking into consideration the specific query patterns, data access requirements, and
performance objectives of the application. Indexes can be created on single columns or
combinations of columns, depending on the frequency and complexity of the queries
performed. However, it's essential to strike a balance between the benefits of indexing and the
associated overhead of index maintenance, as excessive indexing can lead to performance
degradation during data modification operations. By carefully planning and implementing
database indexing, developers can ensure that the application delivers optimal performance
and responsiveness across a variety of usage scenarios, ultimately enhancing user satisfaction
and driving the success of the product.

4.2.2 Front-end Optimization

- 29 -
Front-end optimization constitutes a crucial aspect of performance optimization, focusing on
enhancing the speed, responsiveness, and efficiency of the user interface and client-side
components of a web application. It involves the strategic implementation of various
techniques and strategies aimed at minimizing latency, optimizing resource utilization, and
ensuring a seamless and engaging user experience, particularly in modern web applications
characterized by dynamic content and interactive features.

Front-end optimization encompasses a diverse array of techniques and strategies tailored to

the specific characteristics and requirements of the application. These techniques may include
but are not limited to minimizing HTTP requests, optimizing asset delivery (CSS, JavaScript,
and images), leveraging browser caching mechanisms, implementing code splitting and lazy
loading, and optimizing rendering performance through techniques such as virtualization and
memoization. Additionally, the utilization of performance analysis tools and browser
developer tools can provide valuable insights into the performance characteristics of the
application, enabling developers to identify bottlenecks and areas for optimization. By
adopting a proactive approach to front-end optimization, developers can ensure that the
application delivers a smooth and seamless user experience across a variety of devices and
platforms, ultimately enhancing user satisfaction and driving the success of the product.

4.3 Documentation and Knowledge Transfer

Documentation and knowledge transfer play integral roles in ensuring the long-term
maintainability, scalability, and effective utilization of software applications. Thorough
documentation serves as a vital resource for current and future developers, providing essential
insights into the system architecture, design decisions, implementation details, deployment
procedures, and troubleshooting guidelines. By documenting key aspects of the application,
developers can foster knowledge sharing and collaboration within the development team,
empowering team members to make informed decisions and effectively navigate the
complexities of the codebase.
Documentation can take various forms, including code comments, technical documentation,
user guides, and training materials. Code documentation, in particular, involves adding clear

- 30 -
and concise comments within the source code to elucidate the purpose, functionality, and
logic behind each code block, function, or class. Effective code documentation follows
established best practices, such as using consistent naming conventions, providing descriptive
comments, and adhering to coding standards. Furthermore, user guides and training materials
cater to end-users and stakeholders, offering detailed instructions, explanations, and tutorials
on how to use the application's features and navigate its user interface. By investing in
comprehensive documentation and knowledge transfer initiatives, developers can ensure that
the application remains well-documented, accessible, and comprehensible, thereby facilitating
seamless collaboration, onboarding, and maintenance activities.

4.3.1 Code Documentation

Code documentation serves as a critical component of software development, providing

essential insights into the purpose, functionality, and logic behind each code block, function,
or class. By incorporating clear and concise comments within the source code, developers can
enhance the readability, maintainability, and comprehensibility of the codebase, enabling
current and future developers to understand and navigate the code more effectively. Effective
code documentation not only elucidates the "what" but also the "why" behind certain
implementation choices, empowering developers to make informed decisions and implement
modifications or enhancements with confidence.

To ensure the effectiveness of code documentation, developers should adhere to established

best practices and guidelines. This includes using consistent naming conventions, providing
descriptive comments, and adhering to coding standards and conventions. Additionally,
developers can leverage automated documentation generation tools and plugins to streamline
the documentation process and maintain consistency across the codebase. By prioritizing code
documentation as an integral part of the development process, developers can foster
collaboration, knowledge sharing, and code maintainability, ultimately enhancing the long-
term viability and sustainability of the application.

4.3.2 User Guides and Training Materials

- 31 -
User guides and training materials serve as essential resources for end-users and stakeholders,
offering detailed instructions, explanations, and tutorials on how to effectively utilize the
application's features and functionalities. User guides provide comprehensive documentation
on various aspects of the application, including navigation, data input, system settings, and
troubleshooting procedures. By equipping users with the necessary knowledge and skills to
navigate and utilize the application effectively, user guides facilitate user adoption, reduce
support requests, and enhance overall user satisfaction.

Training materials complement user guides by providing hands-on learning opportunities and
skill development resources for users or stakeholders. These materials may include
instructional videos, step-by-step tutorials, interactive simulations, or hands-on workshops,
tailored to the specific needs and preferences of the target audience. By offering diverse
learning modalities and formats, training materials accommodate different learning styles and
preferences, ensuring that users can acquire the necessary knowledge and skills to maximize
their use of the application. Additionally, user guides and training materials serve as valuable
resources for onboarding new users, providing refresher training for existing users, and
facilitating continuous learning and skill development initiatives within the user community.

Appendices

Code For Frontend of Stopping Train on Pneumatic Brakes Simulation Package: -

Views.py

from django.shortcuts import render from .models import

Breakdata,Coach,Speed,Grade def index(request):
coach_types=Breakdata.objects.all()
coach=Coach.objects.all() speed=Speed.objects.all()
grade=Grade.objects.all()

- 32 -
 context={
"coachtypes":coach_types,
"coach":coach,
"speed":speed,
"grade":grade,
}
return render(request,"index.html",context)

Index.html

{% load static %}
<!DOCTYPE html>
<html lang="en">

</html>
<html>

<head>
<link rel="stylesheet" type="text/css" href="{% static 'css/style.css' %}">
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Coaches Information</title>
</head>

<body>
<div class="container">
<nav class="funky-nav">
<ul>
<li><a href="#">Home</a></li>
<li><a href="#">About</a></li>
<li><a href="#">Services</a></li>
<li><a href="#">Contact</a></li>
<li style="float:right"><a class="active" href="#RDSO">RDSO</a></li>
</ul>
</nav>
<h1 class="page-heading">EMU / DMU</h1>
</div>
<div class="parent-container">
<div class="main-container center">
<div class="left-container">
<h1>Coach Type</h1>
<select id="coach-type">
<option value="Choose" selected>Choose</option>
{% for x in coachtypes %}

- 33 -
 <option value="{{ x.type }}">{{ x.type }}</option>
{% endfor %}
</select>

<h1>Coaches</h1>
<select id="coaches">
<option value="Choose" selected>Choose</option>
{% for y in coach %}
<option value="{{ y.number }}">{{ y.number }}</option>
{% endfor %}
<option value="Other">Other</option>
</select>
<div id="other-coaches-input" class="hidden">
<input type="text" placeholder="Enter custom value">
</div>

<button id="insert-button">Insert</button>

<h1>Speed(kmph)</h1>
<select id="speed-kmph">
<option value="Choose" selected>Choose</option>
{% for y in speed %}
<option value="{{ y.sp }}">{{ y.sp }}</option>
{% endfor %}
<option value="Other">Other</option>
</select>
<div id="other-speed-kmph-input" class="hidden">
<input type="text" placeholder="Enter custom value">
</div>

<h1>Grade</h1>
<select id="grade">
<option value="Choose" selected>Choose</option>
{% for y in grade %}
<option value="{{ y.gd }}">{{ y.gd }}</option>
{% endfor %}
<option value="Other">Other</option>
</select>
<div id="other-grade-input" class="hidden">
<input type="text" placeholder="Enter custom value">
</div>

<button id="calculate-button">Calculate</button>
</div>

<div class="right-container hidden">

- 34 -
 <h1 id="selected-entries-heading">Selected Entries</h1>
<div id="selected-entries">
</div>
<div id="buttons" class="hidden">
<button id="delete-button" class="hidden">Delete</button>
</div>
<button id="finish-button" class="hidden">Finish</button>
<h1 id="e-m-b-heading" class="hidden">Emergency Break Distance</h1>
<div id="e-m-b">
</div>
<div id="buttons" class="hidden">
<button id="print-button" class="hidden">Print</button>
<button id="chart-button" class="hidden">Chart</button>
</div>
</div>
</div>
</div>
<script src="{% static 'js/script.js' %}"></script>
</body>

</html>

- 35 -
Code For Frontend of Compliance Entry For RDSO SMI/TC/MS : -

Smitcmsnew.html
{% extends "portal/base.html" %}

{% block content%}
<style>
body {
overflow-y: scroll;

.tableheader {
background-color: #95BEE6;
color: white; font-weight: bold;
}

.tableheader1 {
color: white; font-
weight: bold;
}

- 36 -
 .tablerow { background-color:
#aaaabd; color: black;
}

.preview_text { text-
align: left; margin: 5px;
display: none; border: 1px
solid #666; padding: 5px;
}

.preview_text { text-
align: left; margin: 5px;
display: none; border: 1px
solid #666; padding: 5px;
}

table { width: 50%;

margin: 20px auto; border-
collapse: collapse;
}

table th, table td {

padding: 8px; border: 1px
solid #ddd; text-align: left;
}

.btn-style { border: 1px solid

#053494; border-radius: 3px;
padding: 8px 16px; background-
color: #053494; color: #ffffff;
cursor: pointer;
}

- 37 -
 .model-loco-container { margin:
4px 0; padding: 5px; /*
Reduced padding */ border: 1px
solid #ccc; border-radius: 5px;
background-color: #f9f9f9; max-
height: 150px;
/* Adjust the maximum height */ overflow-y:
auto;
}
</style>

<form name="dataentry" method="post" action="">

{% csrf_token %} <!-- Include the CSRF token here -->
<div class="message"></div>
<table border="1" cellpadding="10" cellspacing="1" width="50%" align="center">
<tr class="tableheader">
<td align="center" colspan="6">
SMI/TC/MS Entry
</td>
</tr>
<tr class="tablerow">

<td class="td_size">Type
<select name="smi_msmitcms" id="smi_msmitcms" required>
<option value="">--Select--</option>
<option value="SMI">SMI</option>
<option value="TC">TC</option>
<option value="MS">MS</option>
</select>
</td>
<td class="td_size" colspan="2">SMI/TC/MS NO
<textarea rows="1" cols="30" name="smitcmsno" value=""
placeholder="RDSO/{year}/" required></textarea>
</td>

</tr>
<tr class="tablerow">
<td class="td_size">Description of smi/tc/ms
<textarea rows="3" cols="30" name="description" value="" required></textarea>
</td>
<td class="td_size">Date of issue

- 38 -
 <input type="date" size="10" name="doi" value="" class="inputmedium search-
query" required>
</td>
<td class="td_size">File No
<input type="text" name="fileno" value="" required>
</td>
</tr>
<tr class="tablerow">
<td>Loco Equipment
<select name="locoequipment" id="locoequipment" required> <option value="">--
Select--</option>
{% for x in locotypes %}
<option value="{{ x.id }}">{{ x.type1 }}</option>
{% endfor %}
</select>
</td>
<td>Group loco
<select name="grouploco" id="grouploco" required>
<option value="">--Select--</option>
{% for x in group %}
<option value="{{ x.id }}">{{ x.type2 }}</option>
{% endfor %}
</select>
</td>
<td>Loco applicable
<select name="locoappl" id="locoappl" required>
<option value="">--Select--</option>
{% for x in apps %}
<option value="{{ x.id }}">{{ x.type3 }}</option>
{% endfor %}
</select>
</td>
</tr>
<tr class="tablerow">
<td>MODEL LOCO
<div class="model-loco-container">
<input type="checkbox" id="checkAll"> Select All <fieldset>
{% for x in wap %}
<input type="checkbox" name="check_list[]" value="{{ x.id }}">
<label>{{ x.type5 }}</label><br>
{% endfor %}
</fieldset>
</td>
</div>
<td>Status
<select name="status" id="status" required>
<option value="">--Select--</option>
{% for x in stat %}
<option value="{{ x.id }}">{{ x.type4 }}</option>
{% endfor %}

- 39 -
 </select>
</td>
<td></td>
</tr>
<tr class="tableheader">
<td align="center" colspan="6">
<input class="btn-style" type="submit" name="submit_btn" value="Submit"
onClick="clearform();">
</td>
</tr>
</table>
</form>

<script>
document.getElementById("checkAll").addEventListener("click", function () { var
checkboxes = document.getElementsByName("check_list[]"); for (var i = 0; i <
checkboxes.length; i++) { checkboxes[i].checked = this.checked;
}
});

function clearform() {
var checkboxes = document.getElementsByName("check_list[]"); for
(var i = 0; i < checkboxes.length; i++) { checkboxes[i].checked = false;
}
}

</script>
{% endblock %}

Smi_tc_ms_updateview.html

{% extends "portal/base.html" %}

{% block content%}
<style> body {
overflow-y: scroll;
}

- 40 -
 .preview_text { text-
align: left; margin: 5px;
display: none; border: 1px
solid #666; padding: 5px;
} table { width:
50%; margin: 20px auto;
border-collapse: collapse;
}
table th, table td {
padding: 8px; border: 1px
solid #ddd; text-align: left;
}
.tableheader { background-
color: #95BEE6; color: white;
font-weight: bold;
}

.tableheader1 {
color: white; font-
weight: bold;
}

.tablerow { background-
color: #aaaabd; color: black;
}
.preview_text {
text-align: left; margin:
5px; display: none;
border: 1px solid #666;
padding: 5px;
}

.btn-style { border: 1px

solid #053494; border-radius:
3px; padding: 8px 16px;

- 41 -
background-color: #053494;
color: #ffffff; cursor: pointer;
}

</style>

</style>
<form method="post">
{% csrf_token %}
<table>
<tr class="tableheader">
<th colspan="4">Update SMI/TC/MS Entry</th>
</tr>
<tr class="tablerow">

<td class="td_size">Type
<select name="smi_msmitcms" id="smi_msmitcms" required>
<option value="">--Select--
</option>
<option
value="SMI">SMI</option>
<option value="TC">TC</option>
<option value="MS">MS</option>
</select>
</td>
<td class="td_size" colspan="2">SMI/TC/MS
NO
<textarea rows="1" cols="30"
name="smitcmsno" value="" placeholder="RDSO/{year}/"
required></textarea>
</td>

</tr>
<tr class="tablerow">
<td class="td_size">Description of smi/tc/ms
<textarea rows="3" cols="30"
name="description" value="" required></textarea>
</td>
<td class="td_size">Date of issue
<input type="date" size="10"
name="doi" value="" class="input-medium search-query" required>
</td>
<td class="td_size">File No

- 42 -
 <input type="text" name="fileno" value=""
required>
</td>
</tr>
<tr class="tablerow">
<td>Loco Equipment
<select name="locoequipment" id="locoequipment" required>
<option value="">--Select--
</option>
{% for x in locotypes %}
<option value="{{ x.type1 }}">{{
x.type1 }}</option>

{% endfor %}

</select>

</td>

<td>Group loco
<select name="grouploco"
id="grouploco" required>
<option value="">--Select--
</option>

{% for x in group %}
<option value="{{ x.type2 }}">{{
x.type2 }}</option>

{% endfor %}

</select>

</td>

<td>Loco applicable
<select name="locoappl" id="locoappl"
required>
<option value="">--Select--
</option>

{% for x in apps %}

- 43 -
 <option value="{{ x.type3 }}">{{
x.type3 }}</option>

{% endfor %}

</select>

</td>
</tr>
<tr class="tableheader">
<td align="center" colspan="6">
<input class="btn-style" type="submit" name="update_btn" value="Update">
</td>
</tr>
</table>
</form>
{% endblock %}

- 44 -
- 45 -