Finalized Documentnew
Finalized Documentnew
SYSTEM
GROUP MEMBERS
NAME ID
1. Abraham Teshom------------------------------1300159
2. Getish Tadese-----------------------------------1304914
3. Amanuel Mesafint------------------------------1304665
4. Shambel Belay----------------------------------1305942
ADVISOR NAME
____________________________________
i
DECLARATION
The project is our own and has not been presented for a degree at any other university. all the
sources of material used for the project have been duly acknowledged.
Advisor name
-----------------------------
Signature---------------------
Date ------------------------------------
GROUP MEMBERS
NAME ID
1. Abraham Teshom------------------------------1300159
2. Getish Tadese-----------------------------------1304914
3. Amanuel Mesafint------------------------------1304665
4. Shambel Belay----------------------------------1305942
ii
ACKNOWLEDGMENT
Above all, we would like to thank our god, god giving for us the ability to think, analyze ideas,
and be health for patients, as well as the strength to complete our project on time. Next to this, we
would like to thank our Department Information Technology for gave us the brilliant opportunity
to do this project on the topic to develop Android Based online purchasing management system
for Woldia university. We would like express our special thanks of appreciativeness for our
advisors Instructor Mr.-DESALEGN. For his valuable and constructive suggestions during the
planning and development of this project work. His willingness to give his time so generously has
been very much appreciation.
Finally, We are also thankful to purchasing directorate and other staff members for their constant
constructive criticism and invaluable suggestions, which benefited us a lot while developing the
project on “Android based Online purchasing management system”.
iii
LIST OF ACRONYMS FROM OUR DOCUMENT
iv
CONTENTS PAGES
Declaration ...................................................................................................................................... ii
1. introduction ................................................................................................................................. 1
v
2.3.1 Functional Requirements .............................................................................................. 12
References ..................................................................................................................................... 45
vi
ABSTRACT
This project entitled “Android based Online Purchasing Management System for Woldia
university” is designed to keep records of different purchasing informations and make retrieval
or searching of different purchasing information easier.the project has been designed in PHP
Technology.i.e php with html .all of the data need for the application is stored in the form of tables
in phpmyadmin .The main purpose of this project is to develop web based purchasing information
management system for Woldia University campus.our system reduces the manual work and tries
to eliminate or reduce difficulties up to some extent.Generally, the new system replaces the
existing manual system into automated or computerized system that will help to store each and
every purchasing information in a well organized manner.
vii
CHAPTER ONE
1. INTRODUCTION
1.1 BACKGROUND OF THE ORGANIZATION
Woldia University was established in 2009 by Ethiopian government minister of education. It is
located north wollo zone, which is far from Addis Ababa 521km and far from Dessie 120km. The
University began in 2012 with around 600 students in some faculties like Technology, Business
and Economics, Social science and Natural science. To administer well, Strategy planning and
management system is applied in Woldia University to measure performance on strategic planning
and management system and relationally to align the day to day activities to an organization’s
vision and strategy using strategic performance measures and strategic initiatives as other profit
and non profit organizations do. In the institution that has been started its service in 2012 in its
main campus and in 2014 the university has established second campus in mersa and some of the
department like agricultural field of studying are shifted to there and this system allows the
organization to learn what works and to become more strategy focused. So the executives
committed short term and long term plans and strategies to the mission of the institution helping
employees to realize their full potential to evolve the campus to be in the best position to accelerate
new field of studies and learning and teaching methodologies for great achievements of the
institution in a short period of time.
purchasing management system will address these issues by digitizing operations, reducing delays,
and ensuring greater accuracy and accountability in procurement activities.
Woldia University’s current purchasing management system includes a partial web-based solution but still
relies heavily on manual processes, which presents several challenges that hinder the efficiency and
effectiveness of the procurement process. The existing system involves time-intensive activities, such as
slow purchase request submissions, approval processing, and report generation, which cause delays in
acquiring essential goods and services. The continued reliance on paper-based documentation within parts
of the system leads to frequent errors, record duplication, and difficulties in maintaining accurate
procurement data. Furthermore, procurement information is not readily accessible to all stakeholders,
1
limiting transparency. The system also consumes excessive resources, such as paper, storage, and human
effort, particularly in areas where the web-based system has not been fully implemented. Report generation
remains cumbersome, and the paper-based aspects of the system pose security risks, including data loss and
unauthorized access. These challenges highlight the need for a more fully integrated, automated, and user-
friendly solution, such as an Android-based online purchasing management system, to streamline
operations, reduce delays, and enhance accuracy, accountability, and transparency in procurement activities
1.3 OBJECTIVES
1.3.1 GENERAL OBJECTIVE
The general objective of this project is to design and implement an Android-based Online
Purchasing Management System for Woldia University that streamlines the procurement
process, enhances operational efficiency, ensures data accuracy, and promotes transparency
while improving accessibility and accountability through digitization and automation
2
1.4 METHODOLOGY
1.4.1 REQUIREMENT GATHERING METHODS
To understand the needs and challenges of the current purchasing process, we use the following
methods to gather requirements:
Stakeholder Interviews
We conduct structured and semi-structured interviews with key stakeholders, including:
Procurement officers
Administrative staff
Department heads
Suppliers
These interviews focus on understanding their challenges, requirements, and expectations for
the proposed system.
Observation
We observe the existing purchasing processes to identify:
Workflow inefficiencies
Bottlenecks in the approval process
Data handling practices
This helps us gather practical insights into how the procurement system operates in real life.
Document Analysis
We analyze existing documentation, such as:
Purchase request forms
Approval and rejection records
Procurement policies and guidelines
Reports generated by the current system
This analysis provides insights into data fields, formats, and regulations the system must follow.
Surveys and Questionnaires
We distribute surveys and questionnaires to a broader audience, including faculty and staff, to
collect feedback on:
Frequency of use
Common issues faced
3
Desired features and functionalities
Brainstorming Sessions
We organize brainstorming sessions with team members and stakeholders to:
Identify additional requirements
Prioritize features
Explore innovative solutions
Focus Groups
We engage small groups of end-users in discussions to validate findings and refine system
requirements based on their input.
By using these methods, we ensure a comprehensive set of functional and non-functional
requirements, aligning the proposed system with stakeholder needs and expectations.
The technical feasibility of the Online Purchasing Management System has been assessed to
determine whether the required technology is available and suitable for the system's development.
The system will be built for the Android platform, leveraging common technologies such as Java
for the backend and Android Studio for development. We have identified that the required
4
infrastructure, such as modern Android devices, operating systems, and network connectivity, is
readily available. Additionally, the system will utilize cloud storage for data storage and backup,
ensuring scalability and reliability. The system's modular design and integration with existing
university systems have been considered, with a robust API design to ensure smooth data
exchange.
The operational feasibility of the Online Purchasing Management System has been evaluated to
determine whether the university’s operational structure and resources can support the system's
implementation and maintenance. The system has been designed to be user-friendly, requiring
minimal training for the staff involved in the purchasing process. The system will be hosted on
cloud platforms to ensure high availability and performance, and university IT staff will oversee
its maintenance.
The economic feasibility of the Online Purchasing Management System has been analyzed to
assess whether the system can be developed and maintained within the university's budget. The
initial development costs will include software development, testing, and deployment. However,
these costs are outweighed by the long-term benefits, such as reducing manual paperwork,
minimizing errors, improving procurement speed, and automating repetitive tasks. The cloud
hosting services will provide cost-effective scalability, eliminating the need for large upfront
infrastructure investments. Furthermore, the system’s ability to streamline operations and reduce
administrative overhead will result in cost savings over time.
Architectural Design
5
Data Layer: Centralized database to store procurement-related information
securely.
UML Diagrams
Sequence Diagrams: Illustrate the sequence of interactions between system
components.
State Chart Diagrams: Depict the states and transitions of critical system objects,
such as purchase requests.
Class Diagram: used to model the structure of a system, including the objects, their
relationships, and their behaviors.
Database Design
Develop an Entity-Relationship Diagram (ERD) to model database tables and
relationships.
Normalize the database to ensure data integrity and avoid redundancy.
User Interface Design:
Create mockups and prototypes for key application screens, such as login, purchase
requests, and reports.
Focus on usability and intuitive navigation to ensure user-friendliness.
By following the OOSAD methodology, the system will be designed to be robust, scalable, and
adaptable, addressing the current challenges faced by Woldia University’s procurement process.
6
Development and testing will be performed on workstations with adequate processing power and
memory.
Servers will be set up for hosting the backend and database.
Coding and Development
Frontend Development
Develop user interfaces using Android’s XML layouts.
Implement interactive features using Java.
Backend Development
Write server-side logic to process data and enforce business rules.
Create secure APIs for communication between the Android application and the backend server.
Database Integration
Design and create tables in MySQL to store procurement data, user information, and transaction
records.
Implement data access layers for CRUD (Create, Read, Update, Delete) operations.
Testing and Debugging
Unit Testing
We will test individual modules, such as login functionality, request submission, and report
generation, to ensure they function correctly.
Integration Testing
We will test the interaction between the Android application, backend APIs, and the database to
verify seamless integration.
System Testing
We will test the complete system to confirm that all functionalities work as expected and are free
from defects.
User Acceptance Testing (UAT)
We will involve end-users to validate that the system meets their requirements and expectations,
ensuring it is ready for deployment.
Deployment
Server Deployment
We will deploy the backend system and database on a secure web server or cloud platform.
Application Deployment
7
We will distribute the Android application via the Google Play Store or provide it as a direct
APK file for installation. And then students, faculty, and staff can easily download the app from
a trusted source.
Training and Documentation
User Training
We will provide training sessions to familiarize users with the system.
We will prepare user guides and manuals for reference to ensure users can operate the system
effectively.
Technical Documentation
We will document the system’s architecture, APIs, and database schema to support future
maintenance and upgrades.
Maintenance and Support
Bug Fixing
We will address any issues or bugs identified during deployment and use to ensure the system
functions smoothly.
System Updates
We will regularly update the system to incorporate new features or address changing
requirements.
Beneficiaries of Project
The primary beneficiaries of this project are:
University Leadership (President and Campus Dean)
They will request and monitor purchasing needs.
They will ensure that procured items match specifications and budgets.
Purchasing Directorate
They will oversee and manage all purchasing activities.
They will coordinate between departments, suppliers, and purchasing teams.
Administrator
They will manage user accounts and control access.
They will maintain system integrity and monitor operations.
8
Suppliers
They will submit tenders and supply goods and services to the university.
They will access tender notices and results via the platform.
Finance Officers
They will allocate and manage budgets for purchases.
They will approve the financial aspects of requisitions.
Department Heads
They will submit departmental purchasing requests.
They will approve initial requisitions before forwarding them to the purchasing team.
Purchasing Team
They will handle tenders, evaluate submissions, and register winning suppliers.
They will post tender notices online and ensure transparency.
Approval Committees
They will evaluate and approve or reject requests based on budgets and procurement
rules.
Quality Assurers
They will inspect and validate the quality of purchased items to ensure compliance with
specifications.
Property Administration Team
They will register and store received goods.
They will ensure that inventory aligns with procurement records.
Operational Efficiency
The project will automate manual processes, which will reduce delays and
errors in the purchasing workflow.
Enhanced Transparency
By providing a clear record of purchase requests and approvals, the system will
improve accountability and transparency within the university.
Cost Savings
9
By minimizing redundant processes and optimizing resource allocation, the
project will lead to significant cost savings over time.
User Satisfaction
A user-friendly interface and efficient processes will enhance satisfaction among
students, staff, and faculty, fostering a more productive academic environment.
Scalability and Adaptability:
The system will be designed to accommodate the university’s growth and adapt to
changing needs, ensuring long-term relevance and value.
10
1.8 LIMITATIONS OF THE PROJECT
Platform Dependence
The system is designed specifically for Android, limiting accessibility for users on
iOS or other platforms.
Language Barrier
Internet Dependency:
11
CHAPTER TWO
2. SYSTEM FEATURES
2.1 THE EXISTING SYSTEM
Proposed System for Woldia University: Android-Based Purchasing Management System The
proposed system aims to automate the manual purchasing process at Woldia University to ensure
efficiency, transparency, and better resource management. The proposed system will be an
Android-based online purchasing management system. It is designed to digitize and streamline the
entire purchasing workflow, from submitting requests to procurement and final delivery. The
system will enable users at all levels (departments, approval committees, and suppliers) to interact
efficiently.
12
Role-based access control (e.g., Administrator, Department Head, Supplier).
User account creation, activation, and deactivation.
Purchasing Request Management
Submission of purchase requests by departments.
Approval or rejection of requests by the approval committee.
Real-time tracking of request statuses.
Tender Management
Posting of tender notices for suppliers.
Bid registration and submission.
Evaluation and selection of bid winners.
Quality Assurance
Verification of delivered items against specifications.
Rejection of items that do not meet required standards.
Inventory Management
Recording of purchased items in the inventory.
Tracking item usage and availability.
Generation of inventory reports.
Reporting and Analytics
Generating real-time reports on procurement activities.
Budget tracking for departments.
Supplier performance reports.
13
2.3.2 System Use Case
2.3.2.1 Use case Diagram
System
View Purchasing Request
<<include>> <<include>>
reg. school
<<include>>
view approved req. <<include>> <<include>>
Supplier <<include>> School Dean
fill their own detail <<include>> reg.dep,t
<<include>> reg.user
view tendr notice
<<include>>
<<include>>
approve block account
<<include>>
<<include>>
<<include>> Administrator
reject reactivate account
Approve committe <<include>> <<include>>
<<include>>
register model22
view pur_request
view model20
view model19
check item quality
<<include>>
register model19
View Items
quality assurer
Finance officer
Event flows
Event flows
15
2. View model 19 and a letter that comes from winner that has given by inventory department and
purchasing directorate respectively
Description This use case allows Approval committee to approve different purchasing requests
Event flows
Table 4: Business use case for description of Check quality of supplied item
16
Use case Id: Uc5
Description This use case allows quality assurer to Check quality of different supplied item
Event flows
Event flows
1.Registering the purchased items that they receive from the supplier
17
Post condition The model 19 registered successfully
Alternative flows -
Precondition The Winner information must be there to register the winners detail
Event flows
18
BR2: winner must submit original plan of house or 300,000 to HRM.
BR3: Departments, offices, librarians, schools to request purchase with the right specifications of
materials
BR4: Repeated the same material with different number in the same request form is impossible for
example when we fill the request form and we want a number of materials which are the same
items it should be express in number at the same serial number.
BR5: Request the material which is available in store is forbidden.
BR6: The purchasing team can’t analyze the request before the approval committee approve it
BR7: Purchasing workers cannot purchase materials whose price is greater than the approved
Performa
BR8: Purchasing must be done after the validity of materials is checked by the right expert
BR9: The property department cannot receive unchecked purchases
BR10: Any employee cannot put out the materials from inventory department before get the permit
from property administrator team by taking model 20.
To create an Android-based online purchasing management system for Woldia University, we can
adapt its concepts into a mobile user interface (UI) prototype.
Main Features
Proposed Screens
Login Screen
19
Fields: Username, Password.
Button: Login
20
Fields: Name, Contact Info, Items Supplied.
Figure 2.1
21
3. Tools and Technologies
Programming: Java.
waiting for login user enter login info waiting to check machines
check
Valid user
Logged in
22
Start initalization
Open the system
Valid
End
click submit button
23
Initail Select
login Back up
Start Noavailable
Check
Back up Controller
Process
start
Database
Take
Logout
Adminstrator
24
login
Home page
User Login Controller Database
7 : Invalid()
8 : invalid login information()
10 : Valid()
11 : Check()
12 : not existed()
13 : Error worng user information()
25
Create Account
Adminstrator
Admin page
Create Account Controller Database
1 : Login to()
2 : Select()
3 : Create account form request()
6 : Send information()
7 : Invalid()
8 : Invalid user information()
11 : Valid()
12 : send()
26
Request Purchase
7 : Invalid()
8 : Error enter information proporly()
10 : Valid()
11 : send()
12 : successfully send()
27
Take backup
Adminstrator
Adimin page Backup Page Back up Controller Database
1 : Login to()
2 : select()
3 : backup page form request()
4 : Displaytype of backuo to be taken()
5 : Fill form()
6 : send()
7 : invalid()
8 : Display error message()
9 : Re fill form()
10 : send()
11 : valid()
12 : Take backup()
13 : backup successe()
14 : Display Success message()
28
user purchasin team page register winner
Controller Database
1 : login()
2 : select()
3 : Fill Register Winner form()
4 : Display form()
5 : send information()
6 : invalid()
7 : winner is not rergistered()
9 : Valid()
10 : register()
The Analysis Class Model includes essential classes, their attributes, methods, and details about
their relationships, roles, and multiplicities. It provides a foundation for understanding the
structure and interactions within the Android-Based Online Purchasing Management System.
Model Classes
User
Attributes:
29
userName (String): Name of the user.
Methods:
Relationships:
Multiplicity: 1 to * (One-to-Many).
Purchasing Request
Attributes:
Methods:
30
trackStatus(): Provides real-time tracking of the request's status.
Relationships:
Supplier
Attributes:
Methods:
Relationships:
ApprovalCommittee
Attributes:
31
members (List): List of users in the committee.
Methods:
Relationships:
Tender
Attributes:
Methods:
Relationships:
Inventory
Attributes:
32
itemId (String): Unique identifier for an inventory item.
itemName (String): Name of the inventory item.
quantityInStock (int): Number of items currently available.
qualityStatus (String): Quality status of the item (e.g., Verified, Rejected).
Methods:
update Stock(): Updates inventory levels after procurement.
verifyItemQuality(): Checks quality and specification compliance.
Relationships:
Multiple PurchasingRequests are linked to Inventory updates.
Multiplicity: *** to 1 (Many-to-One) **.
BEGIN
Connect to the database
Search for username in the Users table
IF username exists THEN
Compare entered password with the stored password
IF passwords match THEN
Fetch the user's role (e.g., Admin, Supplier, etc.)
Grant access to the appropriate dashboard based on role
RETURN "Authentication successful, Role: [User's Role]"
33
ELSE
RETURN "Authentication failed: Incorrect password"
ENDIF
ELSE
RETURN "Authentication failed: User not found"
ENDIF
END
BEGIN
Validate userId
IF userId is valid THEN
Create a new request record
Assign a unique requestId
Store itemDetails, quantity, justification, and current date in the database
Set the request status to "Pending"
Notify the user of successful submission
RETURN "Request submitted successfully with Request ID: [requestId]"
ELSE
RETURN "Invalid user ID"
ENDIF
END
3. Approval Workflow
Purpose: Routes purchase requests to the approval committee for validation.
34
Pseudo Code:
Algorithm ApproveRequest(requestId, committeeId, budget)
Input: requestId, committeeId, budget
Output: Approval status
BEGIN
Fetch request details using requestId
Validate budget against request amount
IF budget is sufficient THEN
Update the request status to "Approved"
Notify the purchasing team for further action
RETURN "Request Approved"
ELSE
Update the request status to "Rejected"
Notify the user of rejection with reason
RETURN "Request Rejected: Insufficient budget"
ENDIF
END
4. Tender Management
Purpose: Posts tenders and evaluates supplier bids.
Pseudo Code:
Algorithm ManageTender(tenderId, tenderDetails, openDate, closeDate)
Input: tenderId, tenderDetails, openDate, closeDate
Output: Tender posting and bid evaluation
BEGIN
Post tender notice with tenderDetails, openDate, and closeDate
Notify registered suppliers of the tender
WAIT until closeDate for bid submissions
35
Evaluate bids:
FETCH all bids submitted for tenderId
Sort bids based on price, quality, and delivery time
Select the bid with the best value
Register the winning supplier
Notify the winning supplier and update tender status
RETURN "Tender completed with Winner: [supplierId]"
END
5. Inventory Update
Purpose: Updates inventory levels after procurement and performs quality checks.
Pseudo Code:
Algorithm Update Inventory(itemId, quantity, qualityStatus)
Input: itemId, quantity, qualityStatus
Output: Inventory update status
BEGIN
Fetch inventory details using itemId
Validate the qualityStatus of received items
IF qualityStatus is "Pass" THEN
Add quantity to the existing inventory
Update inventory record
RETURN "Inventory updated successfully"
ELSE
RETURN "Quality check failed: Items rejected"
ENDIF
END
6. Report Generation
Purpose: Generates reports for stakeholders based on purchasing activities.
Pseudo Code:
36
Algorithm Generate Report(report Type, date Range)
Input: report Type (e.g., Requests, Approvals, Inventory), date Range
Output: Requested report
BEGIN
SELECT data from the database based on report Type and date Range
IF data exists THEN
Format the data into a readable report (e.g., PDF, Excel)
RETURN "Report generated successfully"
ELSE
RETURN "No data available for the selected criteria"
ENDIF
END
37
Error Handling: The system must provide clear and informative error messages for
unexpected issues, guiding users to resolve them.
Security
Authentication: All users must log in using unique credentials, and passwords must be
stored using secure encryption (e.g., SHA-256).
Authorization: Role-based access control must ensure that users only access
functionalities and data relevant to their roles (e.g., admin, supplier, department head).
Data Encryption: All sensitive data, including communications between the app and the
server, must use end-to-end encryption (e.g., HTTPS with TLS).
Audit Logs: Maintain detailed logs of all user actions (e.g., login, data modification) for
accountability and troubleshooting.
Data Integrity: The system must prevent unauthorized modifications to stored data
through secure database transactions.
Usability
User-Friendly Interface: The system must feature a simple, intuitive interface optimized
for Android devices, with clear navigation and error feedback.
Accessibility: The system should support accessibility features such as large fonts and
voice navigation for visually impaired users.
Localization: The system should support multiple languages, including English and the
local language, for wider usability.
Maintainability
Modularity: The system's architecture must be modular to allow easy updates or
integration of new features without affecting existing functionality.
Documentation: Comprehensive documentation (e.g., user manuals, developer guides)
must be available to facilitate maintenance and user training.
Error Logging: Maintain logs of system errors to simplify debugging and improve future
updates.
Portability
Device Compatibility: The system must work on Android devices running version 8.0
(Oreo) or higher.
38
Server Independence: The backend should be hosted on a cloud platform to ensure
portability and scalability
Availability
Offline Mode: The system should allow users to submit basic requests offline and sync
them automatically when connectivity is restored.
Redundancy: Utilize redundant servers to ensure uninterrupted service in case of hardware
failure.
Scalability
The system must accommodate future increases in data, users, and transactions without
significant architectural changes.
Cloud hosting must allow on-demand scaling of computational resources.
Error Tolerance
The system must detect and recover from unexpected failures (e.g., invalid input,
connectivity loss) without crashing.
User-friendly error messages must provide guidance to users on corrective actions.
39
Backup External HDD, 1 TB Cloud storage with redundancy
Storage
40
Backup Software Rsync or BackupPC for Cloud-based backup
Windows Backup solution
3. Development Tools
Tool Specification
Version Control GitHub
Build Tool Gradle (for Android)
Testing Tools JUnit
API Development Postman
Containerization Docker for packaging and deploying services
Monitoring Tools Prometheus / Grafana
Class Responsibility Collaborator (CRC) Analysis is a structured approach used to identify key
abstractions (classes) in a system. This method helps define the responsibilities of each class and
how they collaborate with other classes. For the Android-based Online Purchasing
Management System, the key abstractions, responsibilities, and collaborators are identified as
follows:
41
Classes and CRC Analysis
Class Responsibilities Collaborators
User Authenticate users via login AuthenticationManager,
credentials. - Manage user roles (e.g., PurchaseRequest, Notification
administrator, requester).
PurchaseRequest Create and track purchase requests. - User, ApprovalCommittee,
Store details such as item type, Notification
quantity, and specifications.
ApprovalCommittee Approve or reject purchase requests. PurchaseRequest, Notification
Verify budget availability for
requests.
Notification Send alerts and updates to users. User, PurchaseRequest,
Notify about approval or rejection of ApprovalCommittee
requests.
Administrator Manage system users and assign User, AuditLog
roles.
Monitor system activities.
AuditLog Record system activities for security Administrator, User
and compliance.
Supplier Submit quotations and participate in PurchaseRequest,
tenders. QualityAssurer
Provide details for delivered items.
QualityAssurer Validate the quality of supplied Supplier, PurchaseRequest
goods.
ReportGenerator Generate detailed procurement and PurchaseRequest,
usage reports. ApprovalCommittee, User
Explanation of CRC Elements
1. Classes: Represent the primary abstractions in the system, such as users, requests, or
notifications.
42
2. Responsibilities: Define what the class is accountable for in terms of the system's
functionality.
3. Collaborators: Identify other classes with which a class interacts to fulfill its
responsibilities.
User
ApprovalCommittee
Notification
43
view
admnistrator
1 *
+id:int register
+name:string purchasing team supplier
campus directorate +password:int
+id:int 1 +id:int
1 +id:int
+reg_emp() +name:string +fname:string
permit +name:string
+createaccount() +password:int +lname:string
+password:int
+reg_campus() +post_notice() +email:string
+submit_req() +itemtype:string
+regist_dep() +register_winner() *
+register_model20() +itemmodel:string
+regis_office() +open_bid()
* 1 +quantity:string
+reactivateaccount() 1
1 +blockaccount() 1 +uit_Price:string
model20 has
+take backup() +total_price:string 1..*
+withdraw_requistion +viewaccount() +applytender()
_no:int +viewlogfile() +view_tenderesul()
+request_no:int has 1 1 1 *
approvalcommite create
requester_body:string submit 1 1
+item_type:string has has
+id:int account 1
+quantity:string +name:string * 1 quality assurer
+permition() +password:int department head +user_id:id
request +id:int
+approve() * 1 1 +user_name:string 1
+name:string
1 +reject() +id:int request
+id:int
1 has +password:string
+password:int
+name:string +role:string
1 +type:string
+password:int status:string +quality()
1..* +specification:strin
g +login()
approve/reject +request() store
+specification:sting * +loout()
+request_date:strin view 1
has 1 1
g
1 1has purchasing
take school dean directorate
+store() property admn_team
check
1 +id:varchar(20) +id:int +id:int
finance officer request +name:varchar(20) +name:string +name:string
1 +password:varchar(20) +password:int +password:int
+id:varchar(20) +request() +reg_item() +view_req()
+name:varchar(20) view_req() 1 +post_notice()
+password:varchar(20) 1 1
+viewmodel19() view
register *
+viewtenderresult() 1
item
model19 *
1 * +item_id:int
view +recipt_no:int +model:sting
model22 +item_type:string *
register +type:string
+model_quantity:int *
+receipt_no:int +unit_price:int
+item_type:string +total_price:int
+order_no:int +store()
quantity:string *
+model:string register
withdraw
+withdraw()
1
take
44
REFERENCES
https://www.geeksforgeeks.org/unified-modeling-language-uml-introduction/
45