SRI RAMAKRISHNA INSTITUTE OF

TECHNOLOGY COIMBATORE-10

(Approved by AICTE, New Delhi – Affiliated to Anna University,

Chennai) (Accredited by NAAC with ‘A’Grade)

(An Autonomous Institution)

Department of Information Technology

20CS007-Object Oriented Analysis and Design

Problem Based Learning Report

CALENDER APPLICATION

Submitted by:

NAME HARINI M
ROLL NO 71382106020
CLASS III rd year (IT)

V-SEMESTER B.TECH(INFORMATION TECHNOLOGY)

ACADEMIC YEAR 2023-2024
 SRI RAMAKRISHNA INSTITUTE OF
TECHNOLOGY COIMBATORE-10
(Approved by AICTE, New Delhi – Affiliated to Anna University,
Chennai) (Accredited by NAAC with ‘A’Grade)
(An Autonomous Institution)

Department of Information Technology

Project Based Learning Report

Certificate

CALENDER APPLICATION
Certified that the project titled _________________________________ is

the bonafide work done by HARINI M in the 20CS007 – Object Oriented Analysis and Design

of this institution , as prescribed by Sri Ramakrishna Institute of Technology for the FOURTH

Semester B.Tech IT programmes during the year 2022 – 2023.

Course Coordinator Head of The Department

Date:

Submitted for the project Viva – voce held on ………………………

Examiner 1 Examiner 2
Chapter no Contents Page no
 CHAPTER-1

HOSPITAL MANAGEMENT SYSTEM

Problem Statement:

"In today's fast-paced and collaborative project-based learning (PBL) environments,

students and educators often struggle to efficiently manage their project timelines, tasks,
and resources. Existing calendar applications lack features tailored to the unique needs of
PBL, such as team scheduling, task dependencies, and progress tracking. As a result, there
is a clear need for a dedicated PBL calendar application that simplifies project
management, enhances collaboration, and ensures successful project completion. The
problem statement is to develop a PBL calendar application that addresses these specific
challenges and empowers students and educators to effectively plan, monitor, and
accomplish project-based learning goals.".

Challenges:

o 1. *Event Synchronization:* Ensuring accurate and real-time syncing across

multiple devices.
o 2. *Conflict Resolution:* Managing overlapping events and resolving scheduling
conflicts.
o 3. *Time Zone Handling:* Dealing with events across different time zones to avoid
confusion.
o 4. *User Interface Design:* Creating an intuitive and user-friendly interface for easy
navigation.
o 5. *Data Security:* Safeguarding sensitive information and preventing unauthorized
access.
o 6. *Notification Management:* Striking a balance with timely reminders without
being intrusive.
o 7. *Integration Complexity:* Seamlessly integrating with other apps and services
for enhanced functionality.
o 8. *Customization:* Allowing users to personalize settings and views to suit their
preferences.

1
 o 9. *Performance Optimization:* Ensuring smooth performance, especially with a
large number of events.
o 10. *Feedback Mechanism:* Establishing effective channels for user feedback to
continually improve the application.

Goals:

o *Efficient Scheduling:* Enable users to easily plan and organize events with a
straightforward scheduling process.
o *Cross-Platform Compatibility:* Ensure seamless integration and synchronization
across various devices and platforms.
o *Intuitive Interface:* Design a user-friendly interface for effortless navigation and
event management.
o *Smart Reminders:* Implement intelligent notification systems to keep users
informed without being intrusive.
o *Collaboration Features:* Facilitate collaboration by allowing users to share and
coordinate events with others.
o *Security Measures:* Prioritize data security to safeguard users' personal and
sensitive information.
o *Continuous Improvement:* Regularly update and enhance the application based on
user feedback and evolving needs.

Requirements:

o *User Authentication:* Implement a secure login system to protect user data.

o *Cross-Platform Compatibility:* Ensure the application functions seamlessly on
various devices and operating systems.
o *Synchronization:* Enable real-time synchronization of events across multiple
devices and platforms.
o *Intuitive Interface:* Design a user-friendly interface for easy navigation and
efficient event management.
o *Reminder System:* Implement customizable and timely reminders to keep users
informed of upcoming events.

2
 o *Collaboration Features:* Allow users to share calendars and collaborate on events
with others.
o *Time Zone Support:* Handle events occurring in different time zones to avoid
confusion.
o *Offline Functionality:* Provide basic functionality even without an internet
connection.
o *Security Measures:* Employ robust security protocols to protect user privacy and
sensitive information.
o *Feedback Mechanism:* Include a feedback system to gather user input for
continuous improvement.
Project scope:
The project scope for a calendar application includes developing a user-friendly interface
for event creation, implementing efficient scheduling algorithms, ensuring cross-platform
compatibility, enabling real-time synchronization across devices, incorporating a smart
reminder system, supporting collaboration features for shared calendars, integrating robust
security measures to protect user data, providing offline functionality, and establishing a
feedback mechanism for continuous improvement. The scope involves creating a
comprehensive and intuitive tool that meets user needs for efficient event planning and
management.
Functional Requirements:

 *Event Creation:* Users should be able to easily create, edit, and delete events with
essential details such as title, date, and time.
 *Synchronization:* The application must synchronize events seamlessly across
multiple devices to maintain up-to-date calendars.
 *Reminder System:* Implement a notification system that allows users to set and
receive timely reminders for upcoming events.
 *Collaboration Features:* Enable users to share calendars and collaborate on events
with others, allowing for efficient coordination.
 *User Authentication:* Implement a secure user authentication system to protect
personal calendar data and ensure privacy.
Non-functional Requirements:

3
  *Performance:* The application should respond quickly, even with a
large number of events, ensuring a smooth user experience.
 *Security:* Employ robust encryption and authentication mechanisms
to safeguard user data against unauthorized access.
 *Scalability:* Design the application to scale efficiently as user data
and usage increase over time.
 *Availability:* Ensure high availability, minimizing downtime and
providing reliable access to calendar functionality.
 *Usability:* Prioritize an intuitive and user-friendly interface, making
the application accessible and easy to navigate for users of varying
technical expertise.
UML Diagrams and Models:

The UML diagrams and models to be developed as part of the project scope include but are
not limited to:
 Use Case Diagrams

 Class Diagrams

 Sequence Diagrams

 Activity Diagrams

 State Diagrams

 Collaboration Diagrams

 Component Diagrams

 Deployment Diagrams

 Package Diagrams

Testing:

 Functional Testing: This checks if the system performs the functions it's supposed
to. For an HMS, it involves testing actions like appointment scheduling, patient
registration, and billing to verify they work as expected.

4
 User Interface Testing: This focuses on the system's user interface, ensuring it's
user-friendly and works smoothly. It involves testing forms, buttons, and user
interactions.
 Integration Testing: This assesses how different components of the HMS work
together. It verifies that modules like patient records, billing, and appointment
scheduling can communicate seamlessly.
 Security Testing: HMS contains sensitive patient data, so security testing ensures
that patient information is protected. It includes checking for vulnerabilities, access
control, and encryption.
 Performance Testing: This tests the system's ability to handle a large number of
users and data. For an HMS, it's essential to ensure it can handle the load, especially
during peak times.
 Usability Testing: It evaluates how easy it is for users (hospital staff, patients, etc.)
to navigate and use the system. This includes assessing the overall user experience.
 Regression Testing: Whenever changes or updates are made to the HMS,
regression testing is performed to ensure that new updates do not negatively affect
existing functionality.
 Compatibility Testing: The HMS must work on various devices and web browsers.
Compatibility testing ensures that the system functions correctly on different
platforms.
 User Acceptance Testing (UAT): In UAT, actual users (hospital staff) test the
system to ensure it meets their needs and expectations.
 Load Testing: This checks how the system performs under heavy traffic and
identifies any performance bottlenecks.
 Data Integrity Testing: Ensures that patient data is accurately stored and retrieved
without any corruption or loss.
 Scalability Testing: As the hospital might grow, scalability testing verifies that the
HMS can handle an increased workload by adding more users, records, and
services.

5
 Chapter-2
UML DIAGRAMS

1. USE CASE DIAGRAM

USECASE DIAGRAM:
A use case diagram is a visual representation in Unified Modeling Language
(UML) that illustrates the interactions between actors (users or external
systems) and a system, showcasing various use cases or functionalities the
system provides. It helps depict the system's scope and functionalities by
presenting actors, use cases, and their relationships, providing a high-level
view of how users interact with the system and the system's responses.
DOCUMENTATION OF USE CASE DIAGRAM:
*Use Case Diagram for Calendar Application*

Actors:

1. *User:* Interacts with the calendar application to manage personal events.

2. *Event Organizer:* Adds and edits events, catering to organizational needs.
3. *Reminder System:* Manages notifications and reminders for events.

6
Use Cases:

1. *View Calendar:*
- Description: Allows the user to view scheduled events on the calendar.
- Actors: User

2. *Add Event:*
- Description: Enables users and event organizers to create new events.
- Actors: User, Event Organizer

3. *Edit Event:*
- Description: Permits users and event organizers to modify existing event details.
- Actors: User, Event Organizer

4. *Delete Event:*
- Description: Allows users and event organizers to remove unwanted events.
- Actors: User, Event Organizer

5. *Share Calendar:*
- Description: Enables users to share their calendar with others for collaborative planning.
- Actors: User

6. *Set Reminder:*
- Description: Allows users to set reminders for upcoming events.
- Actors: User, Reminder System

7. *Search Events:*
- Description: Permits users to search for specific events within the calendar.
- Actors: User

8. *Sync with External Calendars:*

- Description: Allows users to synchronize their calendar with external platforms.
- Actors: User

7
9. *Notifications:*
- Description: Manages the delivery of reminders and notifications.
- Actors: Reminder System

Relationships:

- The *User* can perform various actions such as "View Calendar," "Add Event," "Edit
Event," "Delete Event," "Share Calendar," "Set Reminder," "Search Events," and "Sync
with External Calendars."

- The *Event Organizer* is involved in "Add Event" and "Edit Event" actions.

- The *Reminder System* collaborates with "Set Reminder" to manage "Notifications."

2.CLASS DIAGRAM:

CLASS DIAGRAM :
A class diagram is a type of static structure diagram in Unified Modeling Language (UML)
that represents the structure of a system by illustrating the classes, their attributes, methods,
and the relationships between these classes. It provides a blueprint for the system's objects
and their interactions, highlighting the key entities and their characteristics in a visual
8
format. Class diagrams are fundamental in object-oriented modeling, aiding in the design
and understanding of the architecture of a software system.
DOCUMENTATION OF CLASS DIAGRAM:
Classes:
1. User
- Attributes: userID, username, password, email
- Methods: login(), logout(), register(), resetPassword()

2. Event
- Attributes: eventID, title, location, startDateTime, endDateTime, description
- Methods: createEvent(), updateEvent(), deleteEvent()

3. Calendar
- Attributes: calendarID, name, owner (User), events (list of Event)
- Methods: createCalendar(), addEventToCalendar(), removeEventFromCalendar()

4. Reminder
- Attributes: reminderID, event (Event), time, method (e.g., email, notification)
- Methods: setReminder(), cancelReminder()

5. ExternalCalendar
- Attributes: calendarName, source (e.g., Google Calendar, Apple Calendar)
- Methods: syncWithExternalCalendar(), importEvents(), exportEvents()

6. SearchEngine
- Methods: searchEventsByTitle(), searchEventsByDate()

7. Sharing
- Attributes: sharedCalendar (Calendar), sharedWith (User)
- Methods: shareCalendarWithUser(), revokeAccess()

Relationships:
- A User can have multiple Calendars (1 to many), and a Calendar is owned by one User (1
to 1).

9
- A User can create, update, or delete multiple Events (1 to many), while an Event is
associated with one User (1 to 1).
- A Calendar can have multiple Events (1 to many), and an Event can belong to one
Calendar (1 to 1).
- The ExternalCalendar class represents external calendar sources that the application can
synchronize with, with a many-to-many relationship with the Calendar class.
- The SearchEngine class provides methods for searching events within the application.
- The Sharing class represents the sharing of calendars between Users, allowing multiple
Users to access a shared Calendar.

3.SEQUENCE DIAGRAM:

SEQUENCE DIAGRAM :

10
A sequence diagram is a type of interaction diagram in Unified Modeling Language (UML)
that illustrates the dynamic interactions between objects or components in a system over
time. It represents the flow of messages, actions, and the order of events in a particular
scenario, showcasing how various elements collaborate to achieve a specific functionality.
Sequence diagrams are valuable for visualizing the chronological sequence of interactions
among objects, helping to understand the behavior and communication patterns within a
system during the execution of a particular use case or scenario.
DOCUMENTATON OF SEQUENCE DIAGRAM:
Sequence Diagram: Scheduling an Event

Objects and Participants:

- User
- Calendar
- Event
- Reminder
- External Calendar (Google Calendar)

Actions:
1. User requests to schedule an event.
2. Calendar receives the request and displays the event creation form.
3. User provides event details (title, date, time, description).
4. Calendar creates a new Event object and populates it with the provided details.
5. User sets a reminder for the event.
6. Reminder object is created and linked to the Event.
7. User selects an option to sync the event with an external calendar (e.g., Google
Calendar).
8. Calendar sends a request to the External Calendar object to sync the event.
9. External Calendar processes the request and updates the event on the external calendar.
10. The External Calendar sends a confirmation response.
11. Calendar confirms that the event has been synced with the external calendar.
12. Calendar stores the event in its database.
13. Calendar notifies the User that the event has been successfully scheduled.

11
Arrows and lines with numbers represent the sequence of actions, and you can use lifelines
to show the lifespan of objects. This diagram illustrates the flow of interactions when a user
schedules an event, including creating an event, setting a reminder, and syncing it with an
external calendar. Depending on the specific features and interactions in your calendar
application.

4.COLLABORATION DIAGRAM :

COLLABORATION DIAGRAM :
A collaboration diagram is similar to sequence diagram but the message in number format.
In a
collaboration diagram sequence diagram is indicated by the numbering the message. A
collaboration
diagram, also called a communication diagram or interaction diagram, A sophisticated
modeling tool
can easily convert a collaboration diagram into a sequence diagram and the vice versa. A
collaboration diagram resembles a flowchart that portrays the roles, functionality and
behavior of

12
individual objects as well as the overall operation of the system in real time.
DOCUMENTATON OF COLLABORATION DIAGRAM:
Collaboration Diagram: Scheduling an Event
Objects and Associations:
- User
- Calendar
- Event
- Reminder
- External Calendar (Google Calendar)

Actions:
1. User interacts with the Calendar to schedule an event.
2. The User and Calendar objects are associated to represent the interaction.
3. Calendar creates an Event object and associates it with itself.
4. User provides event details, which are associated with the Event.
5. Calendar creates a Reminder object and associates it with the Event.
6. User sets a reminder for the event, associated with the Reminder.
7. User selects an option to sync the event with an External Calendar.
8. Calendar sends a message to the External Calendar to initiate the synchronization.
9. External Calendar processes the request and updates the event.
10. External Calendar sends a response message to the Calendar.
11. Calendar confirms that the event has been synced with the External Calendar.
12. Calendar stores the Event in its database.
13. Calendar notifies the User of the successful scheduling of the event.

This collaboration diagram visually represents the interactions between objects when a user
schedules an event in a calendar application. It demonstrates how the User, Calendar,
Event, Reminder, and External Calendar objects collaborate to perform this action.

13
5.STATECHART DIAGRAM:

STATECHART DIAGRAM:
The state chart diagram contains the states in the rectangle boxes and starts in indicated by
the dot
and finish is indicated by dot encircled. The purpose of state chart diagram is to understand
the
algorithm in the performing method.
DOCUMENTATON OF STATECHART DIAGRAM:
A state chart diagram, also known as a state machine diagram, represents the various states
and transitions that an object or system can go through in response to events. For a calendar
application, let's create a simplified state chart diagram to represent the states and
transitions of an Event within a Calendar.

State Chart Diagram: Event Lifecycle

States:
- Draft (Initial State): The event is being created but is not yet confirmed.
- Confirmed: The event has been created and is scheduled.
- Canceled: The event has been canceled and is no longer active.

Transitions:
- Create Event: Transition from Draft to Confirmed.
- Cancel Event: Transition from Confirmed to Canceled.
14
- Reschedule Event: Transition from Confirmed to Draft.

Events:
- Create Event: Triggered when a user creates a new event.
- Cancel Event: Triggered when a user cancels an event.
- Reschedule Event: Triggered when a user decides to reschedule an event.

Object:
- Event (Object representing a calendar event)

This state chart diagram visualizes the possible states of an Event within the Calendar
application and the transitions triggered by specific events like creating, canceling, or
rescheduling an event.

6.AVTIVITY DIAGRAM:

15
ACTIVITY DIAGRAM:
An activity diagram is a variation or special case of a state machine in which the states or
activity
representing the performance of operation and transitions are triggered by the completion of
operation. The purpose is to provide view of close and what is going on inside a use case or
among
several classes. An activity is shown as rounded box containing the name of operation.
DOCUMENTATON OF ACTIVITY DIAGRAM:
An activity diagram in a calendar application can illustrate the workflow or process flow
for a specific feature or function. Let's create an activity diagram for scheduling an event in
a calendar application:

Activity Diagram: Scheduling an Event

Activities:
1. Start: The beginning of the activity diagram.
2. User starts the process of scheduling an event.
3. The user provides event details (title, date, time, description).
4. Validation: The system validates the provided details.
5. If validation fails, return to the user to correct input.
6. If validation succeeds, proceed to the next step.
7. User sets a reminder for the event.
8. The user selects the option to sync the event with an external calendar.
9. If "Sync with External Calendar" is selected, go to the "Sync with External Calendar"
subprocess.
10. Create Event: The system creates a new event and stores it in the calendar.
11. End: The end of the scheduling process.

Subprocess - Sync with External Calendar:

1. Start: The beginning of the synchronization subprocess.
2. The system initiates the synchronization process with the external calendar.
3. External Calendar processes the request and updates the event.
4. The external calendar sends a confirmation.
5. The system confirms the successful synchronization.

16
6. End: The end of the synchronization subprocess.

Decisions:
- At step 6, if validation fails, loop back to step 3.
- At step 9, if "Sync with External Calendar" is not selected, skip the synchronization
subprocess.

This activity diagram visualizes the process of scheduling an event in a calendar

application, including the validation of event details, setting a reminder, and optionally
syncing the event with an external calendar.

7.COMPONENT DIAGRAM:

COMPONENT DIAGRAM:
The component diagram is represented by figure dependency and it is a graph of design of
figure
dependency. The component diagram's main purpose is to show the structural relationships
between
the components of systems. It is represented by boxed figure. Dependencies are represented
by
communication association.
DOCUMENTATON OF COMPONENT DIAGRAM:
A Component diagram in a calendar application illustrates the physical distribution of
components and how they interact with hardware or software nodes. Here's a simplified
deployment diagram for a calendar application:

Component Diagram: Calendar Application

17
Nodes:
1. User's Device
2. Application Server
3. Database Server
4. External Calendar Service (e.g., Google Calendar)

Artifacts:
- Calendar Application: The complete application, which includes the User Interface and
Application Logic components.

Associations and component:

1. The User Interface component runs on the User's Device and communicates with the
Application Server for user interactions.

2. The Application Logic component is deployed on the Application Server, handling

business logic and interactions with the Database and External Calendar Service.

3. The Database is hosted on the Database Server, storing event and user data, and is
accessed by the Application Logic component.

4. The External Calendar Integration component interacts with the External Calendar
Service for synchronization with external calendars, which can be hosted externally.

This deployment diagram visualizes the physical distribution of components and their
interactions within the calendar application, including the User's Device, Application
Server, Database Server, and interaction with external calendar services. The specific
architecture and component may vary depending on the implementation and hosting
choices for your calendar application.

8.DEPLOYMENT DIAGRAM:

18
DEPLOYMENT DIAGRAM:
It is a graph of nodes connected by communication association. It is represented by a three
dimensional box. A deployment diagram in the unified modeling language serves to model
the
physical deployment of artifacts on deployment targets. Deployment diagrams show "the
allocation of
artifacts to nodes according to the Deployments defined between them. It is represented by
3-
dimentional box. Dependencies are represented by communication association. The basic
element of a
deployment diagram is a node of two types
DOCUMENTATION OF DEPLOYMENT DIAGRAM:
A deployment diagram in a calendar application illustrates the physical distribution of
components and how they interact with hardware or software nodes. Here's a simplified
deployment diagram for a calendar application:

Deployment Diagram: Calendar Application

Nodes:
1. User's Device
2. Application Server
3. Database Server
4. External Calendar Service (e.g., Google Calendar)

Components:
- User Interface (UI): Represents the frontend of the calendar application running on the
User's Device.
- Application Logic: Represents the backend logic and functionality of the calendar
application running on the Application Server.
- Database: Represents the database storing event and user data, running on the Database
Server.
- External Calendar Integration: Represents the interface to an external calendar service like
Google Calendar.

19
Artifacts:
- Calendar Application: The complete application, which includes the User Interface and
Application Logic components.

Associations and Deployment:

1. The User Interface component runs on the User's Device and communicates with the
Application Server for user interactions.

2. The Application Logic component is deployed on the Application Server, handling

business logic and interactions with the Database and External Calendar Service.

3. The Database is hosted on the Database Server, storing event and user data, and is
accessed by the Application Logic component.

4. The External Calendar Integration component interacts with the External Calendar
Service for synchronization with external calendars, which can be hosted externally.

This deployment diagram visualizes the physical distribution of components and their
interactions within the calendar application, including the User's Device, Application
Server, Database Server, and interaction with external calendar services. The specific
architecture and deployment may vary depending on the implementation and hosting
choices for your calendar application.
9.PACKAGE DIAGRAM:

PACKAGE DIAGRAM:
A package diagram is represented as a folder shown as a large rectangle with a top
attached to its

20
 upper left corner. A package may contain both sub ordinate package and ordinary
model elements.
All uml models and diagrams are organized into package. A package diagram in
unified modeling
language that depicts the dependencies between the packages that make up a model.
A Package
Diagram (PD) shows a grouping of elements in the OO model, and is a Cradle
extension to UML.
PDs can be used to show groups of classes in 2.CLASS DIAGRAMs (CDs), groups
of components or
processes in Component Diagrams (CPDs), or groups of processors in Deployment
Diagrams
(DPDs).
There are three types of layer. They are
 User interface layer
 Domain layer
 Technical services layer
DOCUMENTATION OF PACKAGE DIAGRAM:
Certainly! A package diagram organizes elements into packages, providing a high-level
view of the system's structure. Considering the use case diagram for the calendar
application:

Packages:
1. *User Interface:*
- Contains "View Calendar" and "Notifications" use cases.

2. *Event Management:*
- Includes "Add Event," "Edit Event," and "Delete Event" use cases.

3. *Calendar Sharing:*
- Encompasses "Share Calendar" functionality.

4. *Reminder System:*
- Houses "Set Reminder" and "Notifications" use cases.

5. *Search Functionality:*
- Involves the "Search Events" use case.

6. *External Integration:*
- Covers "Sync with External Calendars."

This package structure organizes the functionalities of the calendar application, making it
more modular and understandable. The relationships between packages reflect the
dependencies and interactions between different aspects of the system.

21
ER DIAGRAM:

DATABASE AND GUI DESIGN:

Database Design

MySql is chosen as the database, tables’ structures and attributes are as the same
as POJO classes in Figure 5. Model Structure shows.

Create table eventType(

eventTypeIDint AUTO_INCREMENT primary key,
eventTypeNamevarchar(50) not null,
contextvarchar(200)
);
alter table eventType
add CONSTRAINT eventTypeName_unique unique(eventTypeName);
create table place(
placeIDint AUTO_INCREMENT primary key,
placeNamevarchar(50) unique not null,
contextvarchar(200)
);
create table eventInfo(
25ventideint AUTO_INCREMENT primary key,
eventNamevarchar(50) not null,
22
imgvarchar(50) ,
img2varchar(50) ,
eventTypeIdint not null,
placeIdint not null,
startDate date not null,
endDate date not null,
contextvarchar(200) ,
pricevarchar(50)
26
);
ALTER TABLE `eventInfo`
DROP INDEX `eventName_unique`;
alter table eventInfo
alter price set default “0” ;
alter table eventInfo
add constraint FK_eventTypeId
FOREIGN KEY(eventTypeId) REFERENCES eventType(eventTypeID);
alter table eventInfo
add constraint FK_placeId
FOREIGN KEY(placeId) REFERENCES place(placeID);
create table sysadmin
(
idint AUTO_INCREMENT primary key ,
adminNamevarchar(20) not null ,
pwdvarchar(20) ,
adminTypeint not null
);

Snippet 1. Database design

The snippet above shows table constraints and primary/foreign key relationships.
In specific, for table eventInfo, it has two foreign keys, placeId and eventTypeId
for inner join query with table place and eventType.
GUI Design
Event Calendar’s graphic user interface design mainly depends on css style sheet
and java script (jQuery UI).
27
jQuery UI is a curated set of user interface interactions, effects, widgets, and
themes built on top of the jQuery JavaScript Library. Whether you're building
highly interactive web applications or you just need to add a date picker to a form
control, jQuery UI is the perfect choice.

Background
 Admin Log In page

23
Figure . Login page

 Home Page

Figure . Home page

24
Figure . Event management page 1 :

 Date picker:

Figure . Date picker

FEATURE WORK:

As mentioned in test, a validation for value length and null value needs to be
developed; Events date can be accurate to date, hour and minute; the
25
purchase system and comment board can be developed for event; at last,
some decoration for front-end display is available.

CONCLUSION:

A calendar app streamlines schedules, fostering organization and time

efficiency. With user-friendly interfaces and customizable features, it simplifies
planning and boosts productivity. Integrating seamlessly into daily life, it's a
digital companion for meetings, events, and deadlines. Syncing across devices
ensures accessibility anytime, anywhere. In conclusion, a robust calendar app
isn't just a tool; it's a key to mastering the art of efficient time management in
the modern, fast-paced world.

26
27