Class

Encapsulation

Object

Object Oriented
Programming

Abstraction

Polymorphism

Inheritance

→

←

→

←

→

System boundary

Include relationship

Generalization
between actors

Checkout
shopping cart

<<include>>

Make payment

Customer
<<extend>>

Search product
by category

Actor
Search product
Guest
<<extend>>

Association

Extend relationship

Search product
by name

Use case

←

→

Class name

Flight
flightNumber: string
departureAirport: Airport

Class properties

arrivalAirport: Airport
durationInMinutes: int
cancelFlight(): bool
addFlightSchedule(): bool
getInstances(): list<FlightInstance>

Class methods

…

…

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type

←

A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

→

Message

Class

Balance Inquiry Transaction
Customer

ATM

Transaction

Account

Screen

GetBalance(Account)
BalanceInquiryTransaction(Account)
GetBalance()
Balance
Balance
DisplayMessage(Balance)
ShowMessage()
Customer

←

ATM

Transaction

Account

Screen

→

Customer opens the online shopping webpage

Customer searches
for a product

More shopping

Customer browses products

Item found

Item not found

View Product

More shopping

Add item to the shopping cart

More shopping

View shopping cart

More shopping

Update items in
the shopping cart

Update shopping cart

Done with shopping

Checkout

←

→

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Member scans their library card
through barcode reader

Member scans the barcode of
the book

System checks if the book can be issued and
that the book is not 'reference only'?

[no]

[yes]
System checks the number of books issued to the member

[max quota exceeded]

[else]
System checks if the book has been reserved
by any other member?

[yes]

[no]
System creates book checkout transaction

System updates the status of the book to 'Loaned'

Show error message

System updates the status of the book to 'Loaned'

System increments number of books issued to the member

System marks any reservation 'Completed' that the member
had made against the book

Show error message

Member scans their library card
through barcode reader

Member scans barcode of the book and
selects to renew the book

System fetches book's details

Check if the book has been returned within
the due date

[no]

Calculate fine

Create transaction
for fine collection

[yes]

See if the book has been reserved
by any other member

Collect fine

[yes]

[no]
Create book checkout transaction
with new due date

Show error message that the
book can't be issued

Update the status of the
book to 'Reserved'

Send notification to the member who has reserved
the book that the book has become available

1
2
3
4
5

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

95
96
97

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

27
28
29
30
31
32
33
34
35
36
37
38
39
40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

←

→

Add parking
display board

<<include>>

Add parking floor

Add electric panel

<<include>>

Add parking spot

Add parking
attendent

Add/modify
parking rate

View account

Add entrance/exit
panel

Update account

Login/Logout
Parking attendant

Admin

Cash payment

Take ticket
Customer
Scan ticket

<<include>>

Pay ticket
<<include>>

Credit card
payment

Assign a parking spot
to a vehicle

Remove a vehicle
from a parking spot

Show parking full
message

Show available
parking spot message

System

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Customer inserts the parking
ticket in the exit panel

System scans the parking ticket and fetches ticket's details

[yes[

Ticket
already paid?

[no]

System calculates the total parking fee

System shows the total parking fee on the display panel and
ask for the credit card details

Customer inserts the credit card in the
card reader

System reads the credit card details
and processes the payment

Payment
successfull?

[no]

[yes]

System shows
the error

Try
again?

[yes]
[no]
System shows success message

Print
receipt?

[yes]

[no]

System sends the signal to open the parking gate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1
2
3
4
5

System prints
the receipt

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

44
45
46
47
48
49
50
51
52

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

←

→

Add product
category

Add product
<<include>>

Modify product
category

Update catalog
Block/Unblock
account

<<include>>
Modify product

Cancel
membership

Update account

Login/Logout

Add credit card
Admin
Add shipping
address
Customer
Checkout
shopping cart

<<include>>

Make payment

Register account
<<extend>>

Guest

Search product
category catalog

Search product
<<extend>> Search product
name catalog
Add item to
shopping card

Update
shopping cart

Send order notification

Send shipment
update notification

System

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Customer opens the online shopping webpage

Customer searches
for a product

More shopping

Customer browses products

Item found

Item not found

View Product

More shopping

Add item to the shopping cart

More shopping

Update items in
the shopping cart

View shopping cart

More shopping

Update shopping cart

Done with shopping

Checkout

Search Catalog
Customer

Catalog

Product

searchProducts(string)
getInfo(string)
Full Product Info
Matching Products Info
Customer

Catalog

Product

Add Items in the ShoppingCart
ShoppingCart

Customer

Item

addItem(productId, quantity)
Error (e.g. Out of Stock)
verifyItem()
Verification Status
Operation success/fail
ShoppingCart

Customer

Item

Checkout and Place an Order
Customer

ShoppingCart

Order

Item

Payment

Shipment

getItems()
Items
getBillingInfo()
getShippingInfo()
createOrder(Items, billingInfo, address)
verifyItem()
verification Status
Error (e.g Item not available)
processPayment(billingInfo, amount)
paymentStatus
Error (e.g. Payment failed)
processShipment(address)
Shipment Status
Order Status
Customer

1
2
3
4
5
6

ShoppingCart

Order

Item

Payment

Shipment

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

←

→

<<include>>

Add question

Add bounty

<<include>>

Add tag

<<include>>
Modify question

<<extends>>

Modify bounty

Cancel
membership
Block/Unblock
account
Update Account

Login/Logout

Reset password
Member

Admin
Add answer

Add comment
Guest

Moderator

Delete/Undelete
question

Add badge to user

Search question
Send notification
View question

Register account

Close question

System

Undelete
question

<<enumeration>>
QuestionStatus

<<enumeration>>
QuestionClosingRemark

<<enumeration>>
AccountStatus

Open
Closed
OnHold
Deleted

Duplicate
OffTopic
TooBroad
NotConstructive
NotARealQuestion
PrimarilyOpinionBased

Active
Blocked
Banned
Compromised
Archived
Unknown
Account

Guest

id: string

registerAccount(): bool
Admin
<<uses>>

Moderator

blockMember(): bool

closeQuestion(): bool

unblockMember(): bool

undeleteQuestion(): bool

<<interface>>
Search

password: string
status: AccountStatus
name: string

1

email: string
phone: string

1

Tag
name: string

reputation: int

Extends

Extends

<<us
es>>

Member

resetPassword(): bool

name: string

Member

description: string

Badge

getReputation(): int

←
ite
vor
s
a
e
f
s
rk
clo
ma
←
←

*

*
Question
title: string

createQuestion(): bool
1

s
ask

*

*

getEmail(): string

1

1
← adds

*

*

*

weeklyAskedFrequency: int

name: string
description: string

*
cre
fla
ate
gs
s→
→
ad
d→

← flags

creates

dailyAskedFrequency: int

collects

*
Comment

*
*

*

description: string

*

text: string
creation: datetime

0..1

viewCount: int

flagCount: int

voteCount: int

Answer

*

answerText: string
0..1

for

accepted: bool

voteCount: int

creationTime: datetime

voteCount: int
incrementVoteCount(): void

updateTime: datetime

*

1

status: QuestionStatus
closingRemark: QuestionClosingRemark

1

1

flagCount: int
create: datetime
increamentFlagCount(): void

1

close(): bool
undelete(): bool
1

*
0..1

*

*

Photo

Bounty
reputation: int
expiry: dateTime
modifyReputation(): bool

Notification

photoId: int

notificationId: int

photoPath: string

createdOn: date

creationDate: dateTime

content: string

delete(): bool

sendNotification(): bool

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

*

Member clicks on the 'Ask Question' button

Member enters the Title and
the Body of the question

Add tag to
the question?

yes

Does tag
exist?
no

validation failed

has enough
reputation

no tags
yes, tag already exists

yes
not enough reputation

Create Tag

Validate
question?

Tag created
successfully?

yes

tag creation failed

validation passed

Save and post the question

Show error to the user

Create a new Question
Member

Question
setTitle()
setBody()
getTags(tagText)
tagId/Error
createTag(tagText, tagDescription)
addTag(tag)

Tag

Bounty

createQuestion(questionText, tagId, bountyValue)
createBounty(bountyValue)
bounty
publishQuestion()
Member

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Question

Tag

Bounty

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

←

→

Add movie

Modify movie

Add show

Search movie
by title

Search movie by
language

<<extend>>

Modify show

Search movie by
release date

<<extend>>
<<extend>>

Search movie by
genre
<<extend>>

Search movie by
city name

Cancel show
<<include>>

<<extend>>

Update/Cancel
booking

Admin

Search movie

Login/Logout/Reset
password

Guest

Front Desk Officer

Create booking
Customer
<<include>>

Assign seat

Make payment
<<include>>
Send booking
notification
Apply coupon
Send new movie
notification

View booking

Refund payment

<<include>>

<<include>>
Cancel booking

Send booking
canceled notification

System

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Customer or front desk officer opens the
search movie page

Customer add the search criteria, dates, number of seats and

Customer add the search criteria, dates, number of seats and
movie title or genre or release date, language or city name.

System searches movies for the
given criteria
[yes]

[no]

Is movie
available?

Tell customer about the
unavailability of movie

[no]

[yes]

See if it is
an existing
customer?

[no]

[yes]

Find customer details

Customer chooses seats
for the movie show

Ask how customer would like to pay
for the booking

Credit card
transaction

Cash
transaction

Customer adds any coupon

Make booking

Ask how customer would like to have
detail of the booking?

Print

Email

Search
again?

Register new customer

Customer inputs their last name and
booking number

System searches booking of the
customer

Check if the
customer has a valid
booking?

[no]

[yes]
Customer choose to cancel the
booking

System cancels the booking and updates movie
show available seats

Check if the
customer is
cancelling before
the cancel
deadline?

[no]

No refund is issued
[yes]
Issue refund

Ask how customer would like to have
detail of the cancellation?

Print

1
2
3
4
5
6
7
8
9

Email

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1
2
3
4
5

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

BEGIN TRANSACTION;
-- Suppose we intend to reserve three seats (IDs: 54, 55, 56) for ShowID=99
Select * From ShowSeat where ShowID=99 && ShowSeatID in (54, 55, 56) && isReserved=0
-- if the number of rows returned by the above statement is NOT three, we can return fail
ure to the user.
update ShowSeat table...
update Booking table ...
COMMIT TRANSACTION;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

48
49
50
51
52
53
54
55

←

→

Balance inquiry
<<extends>>

<<extends>>

Deposit cash

Deposit

<<extends>>
Transaction

<<extends>>
<<extends>>

Cash withdraw

Deposit check

<<extends>>
Transfer

Login/Logout

Change pin

Block/Unblock
account

Customer
Bank

Check remaining
cash
Manager
Generate report

System startup

System shutdown

Refill cash dispenser
Operator

Refill printer receipts

UML conventions

<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Customer inserts the Card in the ATM

System asks for the pin code

Customer enters the pin
[yes]

Valid pin?

[no]

[yes]

retry?

[no]

Display Menu
Show error

Deposit

Withdraw

Transfer

Customer selected a transaction

Balance Inquiry

Customer selects Withdraw from the menu

System shows withdraw options

$20

$40

$100

Custom amount

[Cancel transaction]

Cancel

[Custom amount]

[Predefined amount]

Enter amount

Check available balance

Is amount
greater than the
balance?

[yes]

Notify Customer

[no]
Perform the transaction

Dispense the money

Print
receipt?

[no]

Eject the card

[yes]

Print receipt

Customer selects Deposit Check from the menu

System asks to deposit check in the Deposit Slot

Customer deposits the check

System scans the check

System shows the deposited amount

[no]

is amount
correct?

Customer enters the correct amount
[yes]

Customer selects account, checking or saving?

Add to balance

Show success message to customer

Print
receipt?

[no]

Eject the card

[yes]

Print receipt

Balance Inquiry Transaction
Customer

ATM

Transaction

Account

CheckingAccount

getBalance(Account)
balanceInquiryTransaction(Account)
getBalance()
getBalance()
Balance
Balance
Balance

Screen

Balance
displayMessage(Balance)
showMessage()
Customer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

ATM

Transaction

Account

CheckingAccount

Screen

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

49
50
51
52
53
54
55
56
57

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

←

→

Add/Modify aircraft

Add/Modify flight

Add/Modify flight
schedule
Modify flight
instance
Admin

<<extends>>
Assign pilot/crew

<<include>>

Update/Cancel
reservation

Cancel flight
instance

View flight
instance

Login/Logout/Reset
password

Pilot/Crew
Search flights

Create itinerary

Front Desk Officer

Customer
<<include>>

Create flight
reservation
<<include>>

<<include>>

Add passenger

Assign seat to
passenger

Refund payment

<<include>>

Make payment

Send itinerary
notification

View itinerary

Send flight status
update notification

<<include>>
Cancel itinerary

Send reservation
canceled notification

System

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Customer or front desk officer opens the
search flight page

Customer add the search criteria, dates, seat class (e.g.,
economy etc.), and number of passengers

System searcsh flights for dates
and number of passengers
[yes]

Is there any
flight
available?

[no]

Tell customer about the
unavailability of flights

Search
again?

[yes]
System shows a list of available flights

Customer selects a filght
[no]

See if it is
an existing
customer?

[no]

[yes]
Find customer details

Add passenger's details

Register new customer

Customer chooses seats for each passenger

Ask how customer would like to pay
for the reservation?

Credit card
transaction

Cash
transaction

Check
transaction

Make reservation for flights

Ask how customer would like to have
the detail of the reservation?

Print

Email

System sends the reservation details
for printing or email.

Customer or front desk officer inputs the last name of
any passenger and the reservation number

System searches reservation of
the customer

Check if the
customer has a valid
reservation?

[yes]

[no]
Show error

Search
again?

[yes]
Customer selects to cancel the
reservation

[no]

System cancels the reservation
and updates the flight instances

Check if the
customer is
cancelling before
the cancel
deadline?

[no]

[yes]
Issue refund

Ask how customer would like to have

No refund is issued

Ask how customer would like to have
detail of the cancellation?

Print

Email

System sends the reservation details
for printing or email.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1
2

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

←

→

Modify member

<<extends>>

Block member

<<extends>>
Cancel member
Join a game

Create a new
game

View open
games

Resigns or forfeit
a game
Create hands
Place bet
<<includes>>

Hit

<<includes>>

Draw card

<<includes>>

Player

Dealer

Split
Collect or payout
<<includes>>
Stand

Insurance

Double down

Create account

Cancel
membership

Update account

<<extends>>

Reset password

Login/Logout

<<dataType>>
Person

<<enumeration>>
Suit

name: string
address: Address
email: string
phone: string

Game

Active
Closed
Canceled
Blacklisted
None

1

hit(): void

GameController
validateAction(): bool

Heart
Spade
Club
Diamond

1

start(): bool

manipulates

<<enumeration>>
AccountStatus

Shoe
numberOfDecks: int

1

creates

*

createShoe(): void

split(): void

*

Deck
creationDate: date
getCard(): list<BlackjackCard>

shuffle(): void

stand(): void

1

dealCard(): Card

playAction(): void

1
1

updates

1

Dealer

Player

52
BlackjackCard

hand: Hand

gameValue: int

getTotalScore(): int

getGameValue(): int

bet: int
uses
GameView

totalCash: int
getHands(): void

playAction(): bool

removeHand(): void
Extends

Extends

Extends

sees

BasePlayer

Hand

id: string

1

password: string

1..2

balance: decimal

getScores(): list<int>
addCard(): void
resolveScore(): int

status: AccountStatus
person: Person
hands: Hand[2]
resetPassword(): bool

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

Card
suit: string
faceValue: int
faceValue(): int

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Player starts the game by
placing their bet

Dealer starts the game by dealing 2 cards
for itself and 2 for the player

[yes]

Is the player's
total 21?

[no]

It is a blackjack, player wins,
dealer pays 3:2 of the bet.

[yes]
Is the player total
greater than 21?

[no]

Player looses, dealer
collects the bet

Stand

Hit

Is the dealer's
total less than 17?

Dealer deals another
card for the player

[yes]

[no]

Dealer deals another
card for itself

[no]
Player total greater
than dealer toral?

[no]
Player total less
than dealer total?

[yes]
[yes]
Player wins, dealer
pays equal to the bet

1
2
3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Player looses, dealer
collects the bet

It is a tie, player gets
their bet back

15
16

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

23
24
25
26
27
28
29
30
31
32

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

←

→

Make booking

Add room

<<include>>
Update room
Book room
<<include>>

Remove room

Make payment

Update booking

Guest

Login/Logout

Cancel booking

<<include>>

Refund payment

View booking

Print booking

Search
room/booking

Receptionist

room/booking
Issue room key
Issue check
Send booking
notification

<<include>>
View account

System
Add/update room
house keeping

Check-out
guest
Check-in guest

Register new
account
Add/modify
employee

House Keeper

Add/update room
charge
Server

Issue employee
card

Manager

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Customer arrives at the hotel counter or open the online portal

Search rooms for dates and room type

[yes]

[no]

Is room
available?

Tell customer about the
unavailability of rooms

[no]

[yes]

See if it is
an existing
customer?

[no]

[yes]
Find customer details

Book room

Register new customer

Ask how customer would like to pay
for the booking?

Credit card
transaction

Cash
transaction

Ask how customer would like to have
detail of the booking?

Print

Email

Search
again?

Customer arrives at the hotel
counter

Receptionist searches the
booking of the customer
[yes]

Check if the
customer has a valid
booking?

[no]

Update search?

[yes]

[no]
[no]

See if the room
is ready?

[yes]

Issue room key

Request customer to wait

Update room's booking status to
'Checked-in'

Customer arrives at the hotel counter or
call or access online

Receptionist searches the booking of the customer

Check if the
customer has a valid
booking?

[no]

[yes]

Check if the
customer is cancelling
before the cancel
deadline?

[yes]

[no]

Issue refund

No refund is issued
Ask how customer would like to have
detail of the cancellation?

Print

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1
2

Email

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

33
34
35

←

→

Add Menu
Modify Menu
Add Menu Section
Modify Menu
Section
Add Menu Item
Modify Menu item
Register new
account
Add/Update Table
chart

Cancel account

Reserve Table
Receptionist
Update/Cancel
Reservation

Login/Logout
Manager
Waiter
Place Order

<<include>>

Add Meal
<<include>>

Add order Item
Print Menu

Update Order

Issue Check

View
Order/Account
Chef
Process payment

Cashier

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Waiter arrives at a table and asks for food
order seat by seat

Waiter takes order, seat by seat and keep a
note of the menu items ordered.

Waiter login to the restaurant
management system

Waiter creates a new order for
the table

Waiter creates new meal for a
seat

Waiter add meal items to the
meal

Are there
more seats for
the order?

[no]

Send order to kitchen

[yes]

Customer arrives at the restaurant counter
or calls for table reservation

Customer asks for table reservation for a
certain number of people and date/time

Receptionist searchs tables for
date/time and people count

[no]

Is table
available?

Tell customer about the
unavailability of table

[yes]

See if it is
an existing
customer?

[no]

[yes]
Find customer
details

Reserve table

Register new customer

Ask how customer would like to
receive detail of the reseration

Print

Email

Customer arrives at the restaurant counter or calls

Receptionist searches the reservation of the
customer

Check if the
customer has a valid

[no]

customer has a valid
booking?

[yes]

Receptionist cancels the reservation and update the
table status to 'Free'

Ask how customer would like to have
detail of the cancellation?

Print

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Email

Show error message

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

23
24
25
26
27
28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

1
2
3
4
5
6
7
8
9
10
11
12

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

←

→

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Player moves a piece from Box
b1 to Box b2

Is this a valid move?

[no]

[yes]

Will the player
be under check after
the move?

[yes]

Show message, not a
valid move

[no]

[yes]

Does b2 contain a
piece?

Capture piece at b2
[no]

Is the piece
moved a pawn and
is b2 a back
rank?

[yes]

Promote the pawn to either a queen,
a bishop, a knight or a rock.

[no]

Is this a castling
move?

[yes]

Set the correct
position of rock

[no]

Does this move
result in a checkmate
or stalemate?

[no]

Move the piece to b2

1
2
3
4
5
6
7
8
9
10
11
12
13

[yes]

Show game over
message

14
15
16
17
18
19
20
21
22
23

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

1
2
3
4
5
6
7
8
9
10
11
12
13

13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

52
53
54
55
56
57
58
59
60
61
62
63
64
65

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

←

→

Create account

Block/unblock
member

Cancel
membership

Update account

Login/Logout

Search stock
inventory

Admin
Place market
order

<<uses>>

<<extend>>
<<extend>>

Place order

<<extend>>

Place limit order

Place stop loss
order

<<extend>>

Cancel order

Member

Place stop limit
order

Create/update
Watchlist

Add stock to
Watchlist

Fetch stocks quotes
from stock exchange

View stock
positions

Send order status
change notification

Deposit/Withdraw

Send
deposit/withdrwal
status change
notification

System

notification

Deposit/Withdraw
money
<<includes>>

Transfer Money

<<extend>>

Check Transfer

<<extend>>
Wire transfer

<<extend>>

Electronic bank
transfer

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

User searches and selects the
stock to buy

User selects the order type from market,
limit, stop loss or stop limit

Customer selects the number of stock, time
price limit and time enforcement

Check if enough
deposit is available?

[yes]

[no]

Update
order?

[yes]
[no]
System deduct funds from the account and sends the
order to the stock exchange

System receives acknowledgement
from exchange

System show order placed
message to the customer

User selects an already bought
stock to sell

User selects the order type from market,
limit, stop loss or stop limit

Show error message

limit, stop loss or stop limit

The user selects the number of stock, time
price limit and time enforcement

[yes]

The user selects which stock lots to sell

Check if enough
stocks are available
and all order
parameters are
correct?

[no]

[yes]

Update
order?

[no]

System deduct available stocks from the account and
sends the order to the stock exchange

System receives acknowledgement
from exchange

System show order placed
message to the customer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Show error message

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1
2

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

←

→

Add scanning
code

Remove scanning
code

Modify scanning
code

<<include>>

Add
car/truck/SUV/van/
motorbike
Remove
car/truck/SUV/van/
motorbike

<<include>>

<<include>>

Modify
car/truck/SUV/van/
motorbike

<<include>>

<<include>>

<<include>>

Add vehicle

Remove vehicle

Modify vehicle

Search vehicle
inventory

Create new
account

Update/cancel
account

Login/Logout

<<include>>
Make reservation

Member

<<ex
tend
>>
<<e
xte
nd>
>
<<
ex
ten
<<
d>
ex
>
ten
d>
>

Create
reservation

Add equipment

Add service

Receptionist

Add rental
insurance

Add additional
driver
Update car log

Remove
reservation

Worker

Send overdue
notification

Update
reservation

Pickup vehicle
Send reservation
notification
Return vehicle
System

Send reservation
canceled notification

<<include>>

Pay bill

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

Barcode reader scans the
barcode of the vehicle

Barcode reader scans the barcode of the customer's driving license
or serach the customer by their name

Check if the
customer has a valid
reservation for the
vehicle?

[no]

[yes]
Update status of the vehicle to 'Loaned'

Show error message

Mark any reservation 'Completed' that the
customer has made against the vehicle

Send a vehicle picked-up notification

Barcode reader scans the barcode from
the vehicle

Fetch vehicle details

Check if the
vehicle has been
returned within the
due date?

[no]

Calculate fine

[yes]

Add fine to the bill

Check if
there is any damage
to the vehicle?

[yes]

Calculate fine

Add fine to the bill
[no]
Update car log

Check if the
fuel-tank is full?

[no]

Calculate fine

[yes]

Perform billing
transaction

Create vehicle return transaction

Update vehicle status

Send a vehicle return notification

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Add fine to the bill

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1
2
3
4
5
6
7
8

8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

60
61
62
63
64
65
66
67
68

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

←

→

Search member
<<extend>>

Search company

Search job

<<extend>>

<<extend>>

Search

<<include>>

Add/update
experience
Add/update
education

<<include>>
Add/update
profile

<<include>>

<<include>>
Follow member

Unfollow member

Add/update skill

<<include>>
Add/update
accomplishment
Add/update
recommendation

Send message

Apply for a job

Save job

Block/unblock
member

Member

Admin

Follow company

Unfollow
company

Add/update/delete
post

Add/update/delete
post comment

Send connection
request
Send message
notification
Accept/reject
connection request
Send connection
pending notification
Add job posting
System
Send new suggestion
notification
Create group

Join group

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

User selects 'Add Experience' from the UI

Add Experience UI opens up

User adds Title, Company, Location, Duration and description

[yes]

Upload document
or photo or image

Choose media

Add description
about media

[no]
User presses save
Experience button

Save media

System runs verifications

Notify user about the
missing information

[yes]

Is there missing
information?

[no]

Save 'Experience'

User selects 'Compose a new message' from the UI

New Message UI opens up

User searches/selects member to send message

User adds body of the message

Upload document
or photo or image

[yes]

Choose media

[no]
User presses send
message button

System runs verifications

Notify user about the
missing information

[yes]

Is there missing
information?

[no]

Send message to all the requested members

Send email and push notification about the new
message to all the requested members

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Upload media

14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5

5
6
7
8
9
10
11
12
13
14
15
16
17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

←

→

Add/modify player

Add/modify team

Add/modify
tournament

Add/modify team
squad

Add/modify
innings

Add/modify over
Add/modify run
<<include>>
Add/modify ball
<<include>>
Add/modify
wicket

Add/update player
contract

Add T20

Admin

<<extend>>

Add test
<<extend>>

Add ODI

Add/modify
commentry

<<extend>>

Commentator

Add match

Add/update news

Add/modify
statdium

Accept/modify
umpire, referee
<<extends>>
Add/update stats

<<extends>>

<<extends>>

Add/update
player stats
Add/update
match stats

Add/update
tournament stats

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

User selects 'Add Ball' from the
UI

'Add Ball' UI opens up

User selects ball type - Normal, Wide, NoBall
or a wicket tacking ball

Was there any
wicket taken on this
ball?

[yes]

Add Wicket details

[no]

Was there any
runs scored on the
ball?

[no]

Add commentary of the ball

Save Ball

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

[yes]

Add new Run record
for each RunType

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

31
32
33
34
35
36
37
38

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

←

→

Search group

Search page

Search member
<<extend>>
<<extend>>

<<extend>>

Search posts

<<extend>>
Search

Add/update work
<<include>>

Add/update
profile

Follow member

<<include>>
<<include>>

Add/update
education

Add/update place

Unfollow member

Send message

Create page

Follow page

Member

Unfollow page

Recommend a
page

Add/update/delete

Block/unblock
member

Enable/disable
page

Admin

Add/update/delete
post

Add/update/delete
post comment

Send connection
request
Send message
notification
Accept/reject
connection request
Send connection
pending notification
Like/share post
System

Create group

Join group

Send new suggestion
notification

UML conventions
<<interface>>
Name
method1()

Interface: Classes implement interfaces, denoted by Generalization.

ClassName
property_name: type

Class: Every class can have properties and methods.
Abstract classes are identified by their Italic names.

method(): type
A

B

Generalization: A implements B.

A

B

Inheritance: A inherits from B. A "is-a" B.

A

B

Use Interface: A uses interface B.

A

B

Association: A and B call each other.

A

B

Uni-directional Association: A can call B, but not vice versa.

A

B

Aggregation: A "has-an" instance of B. B can exist without A.

A

B

Composition: A "has-an" instance of B. B cannot exist without A.

User selects 'Add Work' from the UI

'Add Work' UI opens up

User adds Position, Company, Location,
Duration and Description

User presses 'Save Work'
button

System runs verifications

Notify user about the
missing information

[yes]

Is there missing
information?

[no]

Save 'Work'

User selects 'Compose a new post' from the UI

'New Post' UI opens up

User set the privacy list to whom the
post will be visible

User adds text of the post

Upload photo or
video?

[no]
User presses publish post
button

System runs verifications

[yes]

Choose media

Upload media

Notify user about the
missing information

[yes]

Is there missing
information?

[no]

Publish post for all the requested members

Send email or push notification about the new
post to the members

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

1
2
3
4
5
6
7
8
9
10
11
12

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

←

→