Class diagram

Class-diagram

@startuml
' ===== HmH Klassediagram – FIXED (Minimal Changes) =====

abstract class User {
  - int userId
  - String firstName
  - String lastName
  - String email
  - String passwordHash
  + getUserId() : int 
  {abstract} + getRole() : String
  + getFirstName() : String  
  + getLastName() : String
  + getEmail() : String
  + getPasswordHash() : String
  + verifyPassword(password : char[]) : Boolean
}

class Customer extends User {
  - List<Integer> preferredCauses
  + Customer(...)
  + getRole() : String
  + getPreferences() : List<Integer>
  + addPreference(orgNumber : int) : void
  + removePreference(orgNumber : int) : void
}

class Organization <<record>>{
    - int orgNumber
    - String name 
    - boolean trusted
    - String websiteURL
    - boolean isPreApproved
    - String description
    + Organization(...)
    + getOrgNumber() : int
    + getName() : String
    + isTrusted() : boolean
    + getWebsiteURL() : String
    + isPreApproved() : boolean
    + description() : String
}

class Donation <<record>> { 
    - int donationId
    - int userId
    - int organizationId
    - BigDecimal amount
    - Timestamp date
    - String paymentMethod
    + Donation(...)
    + donationId() : int
    + userId() : int
    + organizationId() : int
    + amount() : BigDecimal
    + date() : Timestamp
    + paymentMethod() : String
}

' ===== Repository Layer =====
abstract class Repository {
  # Map<K, V> content
  # Repository(Map<K, V> content)
  + getContent() : Collection<Object>
}

abstract class DBRepository extends Repository {
  # Map<K, V> contentLock
  # DBRepository(Map<K, V> content)
  # updateContentLock() : void
  + addContent(K key, V value)
  {abstract} + List<Object[]> export() : List<Object[]>
}

class UserRepository extends DBRepository {
  - _ROLE_CUSTOMER = "Customer"
  + UserRepository(List<Object[]> rows)
  + export() : List<Object[]>
  + getUsers() : HashMap<Integer, User>
  + getuserById(userId : int) : User
  + addUser(user : User) : boolean
  + findUserByEmail(email : String) : User
}

class DonationRepository extends DBRepository {
  - List<Object[]> rows
  + DonationRepository(List<Object[]> rows)
  + export() : List<Object[]> 
  + getDonationById(donationId : int) : Donation 
  + addDonation(donation : Donation) : boolean
  + sortByDate() : List<Donation>
  + sortByAmount() : List<Donation>
  + filterByOrganization(orgNumber : int) : List<Donation>
  + filterByUser(userId : int) : List<Donation>
}

class OrganizationRepository extends Repository {
  - HashMap<Integer, Organization> grandMap
  + OrganizationRepository(Object[] input)
  + export() : Object[]
  + getTrustedOrganizations() : HashMap<Integer, Organization>
  + findByorgNumber(orgNumber : int) : Organization
  + findByOrgName(name : String) : Organization
}

' ===== Service Layer (NEW but minimal) =====
class DonationService {
  - DonationRepository donationRepository
  - OrganizationRepository organizationRepository
  + DonationService(DonationRepository donationRepo, OrganizationRepository orgRepo)
  + getDonationRepository() : DonationRepository
  + getOrganizationRepository() : OrganizationRepository
  + donate(customer : Customer, orgNumber : int, amount : BigDecimal) : boolean 
}
class UserService {
    - UserRepository userRepository
    + UserService(UserRepository userRepository)
    + getUserRepository() : UserRepository
    + registerUser(role, firstName, lastName, email, passwordHash) : boolean
    + login(email : String, password : char[]) : boolean
    + logout() : void
}



' ===== Wrapper Layer =====
abstract class Wrapper {
  {abstract} + import() : Object
  {abstract} + export(Object content) : Boolean
}

class OrgApiWrapper extends Wrapper {
  - Object[] data
  - HttpClient client
  - HttpRequest request
  + OrgApiWrapper(String apiEndpoint)
  + importData() : boolean
  + getData() : Object[]
}

abstract class DBWrapper extends Wrapper {
  - String PATH
  # DBWrapper(String path)
  {abstract} + import() : Hashmap<Object, Object> 
  {abstract} + export(Hashmap<Object, Object> entity) : Boolean
}

class UserDBWrapper extends DBWrapper {
  + UserDBWrapper(String path)
  + import() : Hashmap<String email, User>
  + export(Hashmap<String email, User>) : Boolean
}

class DonationDBWrapper extends DBWrapper {
  + DonationDBWrapper(String path)
  + import() : Hashmap<orgNumber int, Donation>
  + export(Hashmap<orgNumber int, Donation>) : Boolean
}

' ===== Repository to Wrapper =====
UserRepository --> UserDBWrapper
DonationRepository --> DonationDBWrapper
OrganizationRepository --> OrgApiWrapper

' ===== Service Layer =====
DonationService --> DonationRepository       : uses / stores
DonationService --> OrganizationRepository   : validates
DonationService --> Donation                : creates
UserService --> UserRepository : uses / stores
UserService --> Customer : creates

' ===== Domain relationships =====
Donation --> Customer       : donated by
Donation --> Organization   : donated to
Customer o-- Organization  : preferences
OrganizationRepository o-- Organization : manages

@enduml