UML - ATM Transaction - Use Case Diagram

Use case diagram on ATM transaction

So in the previous video we have discussed the problem statement and the respective functional and non-functional requirements

on this ATM transaction. So let us discuss about the use case diagrams

how to draw the use case diagram for this ATM transaction case study

So here we have drawn one use case diagram. You know that we have discussed that one in the use case diagram chapter

chapter that a single project might be having hundreds of use cases might be

having multiple use cases and each and every use case where we are going for

the detailing about the system so just consider this use case here we are having

one actor this actor is nothing but the customer and this customer what are

the use cases what are the functional requirements this customer can initiate what are the processes the customer can initiate so here

we are expressing that one using use cases so this ellipse are denoting the use case and this

actor is is nothing but the customer who is working as an actor here we have discussed in the

use case class also that use case in case of use case the actor may not be always the human

being maybe some application which is the internal application or external application

as an example we can consider that a trigger of a certain database can also

be treated as an actor here. So what are the operations this user this customer can

initiate? There is a deposit funds, withdraw money, view balance, make payment and change

pin and transfer of funds. So these are the different use cases. These are the different

functional requirements this particular customer can initiate. So here we see that make

payment will be also will be sanctioned or will be acted by this credit system

and this change of pain will be approved by the bank officer don't think that

they are the human being they may be the software applications or software

models use case diagram for an ATM that is automated Taylor machine now

let us discuss what are the do's and dons while drawing the use case diagram

so do not model actor to actor communication we should not connect actor to actor But in case of say abstract class and then concrete class they will be drawing the actor to actor communication but that is a special case we be discussing that one

in this particular video but actor to actor communication is not should not be done do not

draw an arrow directly between two use cases we know that in between two use cases we

sometimes draw some arrows where we'll be having our uses or where we'll be having our uses or where we'll be having

our extents so that is a different thing but between two use cases we should not draw

any arrow directly every use case must be initialized by an actor so what is the use case

there is a functional requirement so against that particular functional requirement some process is to be executed so that's why always one use case must be initiated

by some actor a database has to be thought as an underneath layer of the entered use

diagram always remember whenever you were in a project software project always

remember that is one underneath layer of database so keeping that one in

mind we are doing going for this use case diagram it is a very high level

diagram I know that database will be coming at the back end but when whenever you

are drawing these use cases or any other diagram always remember there is an

underneath layer of database in the project so now just consider this one

we're having the abstract use case so this this is an abstract use case. So this particular abstract use case is withdraw money

This abstract use case has got extended here. So here we have written this one as

extends and there is a make express withdrawal. And here we are having this uses that is

authenticate customer. So this particular functional requirement will be used while withdraw money and this particular withdraw money is having the extended version

that is a make express withdrawal so this is there is one use case there are the other use cases

you are finding that you are having the direct communication between use cases but remember the

labels are there extends and uses so an abstract use case is one that is not started directly by an

actor instead an abstract use case provides some additional functionality that can be used by other

use cases so its additional functionality will be obtained here Okay abstract use case are the use cases that participate in a use or extends uses or extends relationship

So in this way we have shown that how this abstract use cases can be used in our use case diagram

Now we are considering the abstract actor. It is an actor that has no instances, that is the actor's cardinality exactly zero

know that in case of abstract class we don't define any kind of objects under that and

whenever we are going for the concrete classes then we define the respective objects

so keeping that one in mind it is not a in a class diagram I know that one

but keeping that concept in mind we're here we're having this abstract actor

there is an employee this is a note and this a note connectivity line is there so

abstract actor these are the concrete actors there is an hourly employee

salaried employee and temporary employee and this is the employee so these properties will be

coming to this respective this hourly employee salaried employee and the temporary employee

so here we're giving you some idea of this abstract actor and concrete actor

so let us go for one demonstration using rational row software and how to draw such

use cases and how to access the software so please watch the demonstration now

In this demonstration, we are going to show you how to draw use case diagram using rational

rows software for a project on ATM that is automated tailor machine

So we are coming to this use case and double clicking on this main, this window will

pop up. And here you see we're having the list of buttons coming in the toolbar

So here we're having this generalization, here we're having the dependency or instance

sheets this is the respective buttons for unidirectional association actor we're having the use case we're having the respective note we're having some text to

be written here using the text box tool and here we're having the anchor note to

item so let me show you that how to draw the use case diagram using this

toolbar so I'm just renaming this one so transfer funds bringing the actor here giving the name as customer customer

Now using this one we are going for this association

this particular make payment will be initiated by the actor so the line has been

drawn accordingly so here we are putting one text using this text box tool so here we have

completed the use case diogen so here we have completed the use case drawing for this ATM and here you have shown you that how to use this toolbar

how to use this tool to draw this diagram thanks for watching this video