package model;

import [Link];

import [Link];

import [Link];

public class AttendanceRecord {

private String trainingId;

private String playerId;

private boolean present;

public AttendanceRecord() {

public AttendanceRecord(String trainingId, String playerId, boolean

present) {

[Link] = trainingId;

[Link] = playerId;

[Link] = present;

public String getTrainingId() {

return trainingId;

public void setTrainingId(String trainingId) {

[Link] = trainingId;
 }

public String getPlayerId() {

return playerId;

public void setPlayerId(String playerId) {

[Link] = playerId;

public boolean isPresent() {

return present;

public void setPresent(boolean present) {

[Link] = present;

public void showInfo() {

[Link]("| %-8s | %-6s | %-10s%n", trainingId, playerId,

present);

}
package model;

public class MatchRecord {

private String matchId;

private String date;

private String opponentTeam;

private String matchType;

public static final String[] VALID_MATCHTYPE = {"Friendly", "League",

"Cup"};

public MatchRecord() {

public MatchRecord(String matchId, String date, String opponentTeam,

String matchType) {

[Link] = matchId;

[Link] = date;

[Link] = opponentTeam;

[Link] = matchType;

public String getMatchId() {

return matchId;

public void setMatchId(String matchId) {

 [Link] = matchId;

public String getDate() {

return date;

public void setDate(String date) {

[Link] = date;

public String getOpponentTeam() {

return opponentTeam;

public void setOpponentTeam(String opponentTeam) {

[Link] = opponentTeam;

public String getMatchType() {

return matchType;

public void setMatchType(String matchType) {

[Link] = matchType;

}
 public void showInfo() {

[Link]("Match ID: %s\nDate: %s\nOpponent Team: %s\

nMatch Type: %s", matchId, date, opponentTeam, matchType);

@Override

public String toString() {

return [Link]("Match ID: %s\nDate: %s\nOpponent Team: %s\

nMatch Type: %s", matchId, date, opponentTeam, matchType);

package model;

public class PerformanceRecord {

private String matchId;

private String playerId;

private int goals;

private int assists;

private int yellowCards;

private int redCards;

private int minutesPlayed;

public PerformanceRecord() {

}
 public PerformanceRecord(String matchId, String playerId, int goals, int
assists, int yellowCards, int redCards, int minutesPlayed) {

[Link] = matchId;

[Link] = playerId;

[Link] = goals;

[Link] = assists;

[Link] = yellowCards;

[Link] = redCards;

[Link] = minutesPlayed;

public String getMatchId() {

return matchId;

public void setMatchId(String matchId) {

[Link] = matchId;

public String getPlayerId() {

return playerId;

public void setPlayerId(String playerId) {

[Link] = playerId;

}
public int getGoals() {

return goals;

public void setGoals(int goals) {

if (goals >= 0) {

[Link] = goals;

} else {

[Link]("Goals must not be negative.");

public int getAssists() {

return assists;

public void setAssists(int assists) {

if (assists >= 0) {

[Link] = assists;

} else {

[Link]("Assists must not be negative.");

public int getYellowCards() {

return yellowCards;

}
public void setYellowCards(int yellowCards) {

[Link] = yellowCards;

public int getRedCards() {

return redCards;

public void setRedCards(int redCards) {

[Link] = redCards;

public int getMinutesPlayed() {

return minutesPlayed;

public void setMinutesPlayed(int minutesPlayed) {

if (minutesPlayed >= 0 && minutesPlayed <= 120) {

[Link] = minutesPlayed;

} else {

[Link]("Minutes played must be from 0 to 120.");

public int calculatePerformancePoints() {

int point = goals * 5 + assists * 3 - yellowCards * 1 - redCards * 3;

 return [Link](point, 0);

public void showInfo() {

[Link]("| %-6s | %-6s | %3d | %3d | %4d | %4d%n", matchId,

playerId, goals, assists, minutesPlayed, calculatePerformancePoints());

package model;

import [Link];

public class Player {

protected String playerId;

protected String fullName;

protected int age;

protected String nationality;

protected String position;

protected int shirtNumber;

protected double baseSalary;

protected String playerType;

protected String status;

public static final String[] VALID_POSITIONS = {"Goalkeeper", "Defender",

"Midfielder", "Forward"};

public static final String STATUS_ACTIVE = "Active";

 public static final String STATUS_INACTIVE = "Inactive";

public Player() {

public Player(String playerId, String fullName, int age, String nationality,

String position, int shirtNumber, double baseSalary, String playerType, String
status) {

[Link] = playerId;

[Link] = fullName;

[Link] = age;

[Link] = nationality;

[Link] = position;

[Link] = shirtNumber;

[Link] = baseSalary;

[Link] = playerType;

[Link] = status;

public String getPlayerId() {

return playerId;

public void setPlayerId(String playerId) {

[Link] = playerId;

}
public String getFullName() {

return fullName;

public void setFullName(String fullName) {

[Link] = fullName;

public int getAge() {

return age;

public void setAge(int age) {

if (age >= 16 && age <= 45) {

[Link] = age;

} else {

[Link]("Age must be between 16 and 45.");

public String getNationality() {

return nationality;

public void setNationality(String nationality) {

[Link] = nationality;

}
public String getPosition() {

return position;

public void setPosition(String position) {

[Link] = position;

public int getShirtNumber() {

return shirtNumber;

public void setShirtNumber(int shirtNumber) {

if (shirtNumber >= 1 && shirtNumber <= 99) {

[Link] = shirtNumber;

} else {

[Link]("Shirt number must be between 1 and 99.");

public double getBaseSalary() {

return baseSalary;

public void setBaseSalary(double baseSalary) {

[Link] = baseSalary;
 }

public String getPlayerType() {

return playerType;

public void setPlayerType(String playerType) {

[Link] = playerType;

public String getStatus() {

return status;

public void setStatus(String status) {

[Link] = status;

public void showInfo() {

[Link]("Player ID: %s\nFull name: %s\nAge: %d\nNationality:

%s\nPosition: %s\nShirt Number: %d\nBase Salary: %f\nPlayer Type: %s\
nStatus: %s\n",

playerId , fullName, age, nationality, position, shirtNumber,

baseSalary, playerType, status);

@Override

public String toString() {

 return [Link]("Player ID: %s\nFull name: %s\nAge: %d\
nNationality: %s\nPosition: %s\nShirt Number: %d\nBase Salary: %f\nPlayer
Type: %s\nStatus: %\ns",

playerId , fullName, age, nationality, position, shirtNumber,

baseSalary, playerType, status);

public boolean isActive() {

return STATUS_ACTIVE.equalsIgnoreCase([Link]);

public boolean isValidPosition(String position) {

for (String p : VALID_POSITIONS) {

if ([Link](position)) {

return true;

return false;

public double calculateBonus(int monthlyPerformancePoints){

return 0;

public double calculateMonthlySalary(int monthlyPerformancePoints){

return 0;

}
package model;

public class RegularPlayer extends Player {

private double bonus;

public RegularPlayer(String playerId, String fullName, int age, String

nationality, String position, int shirtNumber, double baseSalary, String
playerType, String status, double bonus) {

super(playerId, fullName, age, nationality, position, shirtNumber,

baseSalary, playerType, status);

[Link] = bonus;

public RegularPlayer() {

@Override

public double calculateMonthlySalary(int monthlyPerformancePoints){

return getBaseSalary();

package model;

public class SalaryRecord {

private String playerId;

 private int month;

private int year;

private double baseSalary;

private double bonus;

public SalaryRecord(String playerId, int month, int year, double

baseSalary, double bonus) {

[Link] = playerId;

[Link] = month;

[Link] = year;

[Link] = baseSalary;

[Link] = bonus;

public SalaryRecord() {

public String getPlayerId() {

return playerId;

public void setPlayerId(String playerId) {

[Link] = playerId;

public int getMonth() {

return month;
}

public void setMonth(int month) {

[Link] = month;

public int getYear() {

return year;

public void setYear(int year) {

[Link] = year;

public double getBaseSalary() {

return baseSalary;

public void setBaseSalary(double baseSalary) {

[Link] = baseSalary;

public double getBonus() {

return bonus;

public void setBonus(double bonus) {

 [Link] = bonus;

public double getTotalSalary(){

return [Link] + [Link];

@Override

public String toString() {

return [Link]("|%-10s|%-6d|%-6d|%.2f|%.2f|\n" ,
playerId,month,year,baseSalary,bonus);

package model;

public class StarPlayer extends Player {

private static final double BONUS_PER_POINT = 500_000;

private double bonus;

public StarPlayer(double bonus, String playerId, String fullName, int age,

String nationality, String position, int shirtNumber, double baseSalary, String
playerType, String status) {

super(playerId, fullName, age, nationality, position, shirtNumber,

baseSalary, playerType, status);

[Link] = bonus;

}
 public StarPlayer() {

@Override

public double calculateBonus(int monthlyPerformancePoints){

return monthlyPerformancePoints * BONUS_PER_POINT;

@Override

public double calculateMonthlySalary(int monthlyPerformancePoints){

return getBaseSalary() + calculateBonus(monthlyPerformancePoints);

package model;

public class TrainingSession {

private String trainingId;

private String date;

private String location;

private String topic;

public TrainingSession() {

public TrainingSession(String trainingId, String date, String location, String

topic) {
 [Link] = trainingId;

[Link] = date;

[Link] = location;

[Link] = topic;

public String getTrainingId() {

return trainingId;

public void setTrainingId(String trainingId) {

[Link] = trainingId;

public String getDate() {

return date;

public void setDate(String date) {

[Link] = date;

public String getLocation() {

return location;

public void setLocation(String location) {

 [Link] = location;

public String getTopic() {

return topic;

public void setTopic(String topic) {

[Link] = topic;

public void showInfo() {

[Link]("Training ID: %s\nDate: %s\nLocation: %s\nTopic: %s",

trainingId, date, location, topic);

@Override

public String toString() {

return [Link]("Training ID: %s\nDate: %s\nLocation: %s\nTopic:

%s", trainingId, date, location, topic);

package manager;

import [Link];

import [Link];
import [Link];

import [Link];

import [Link];

public class AttendanceManager {

private ArrayList<AttendanceRecord> attendanceList = new

ArrayList<>();

private TrainingSession t;

private PlayerManager pm;

private Scanner sc = new Scanner([Link]);

private AttendanceRecord a;

public AttendanceManager() {

public AttendanceManager(PlayerManager pm) {

[Link] = pm;

public AttendanceManager(ArrayList<AttendanceRecord> attendanceList)

{

[Link] = attendanceList;

public ArrayList<AttendanceRecord> getAttendanceList() {

return attendanceList;
 }

public void setAttendanceList(ArrayList<AttendanceRecord>

attendanceList) {

[Link] = attendanceList;

public void recordAttendance() {

[Link]("---------- RECORD TRAINING ATTENDANCE ----------");

[Link]("Training ID: ");

String trainingId = [Link]().trim();

[Link]("Date: ");

String date = [Link]().trim();

ArrayList<Player> activePlayers = [Link]();

[Link]("Total Active Players: " + [Link]());

[Link]("Enter absent Player IDs, separated by commas.");

[Link]("Leave blank if all included active players are

present.");

[Link]("Absent Player IDs: ");

String input = [Link]().trim();

ArrayList<String> absentIds = new ArrayList<>();

if (![Link]()) {

String[] ids = [Link](",");

for (String id : ids) {

 [Link]([Link]());

[Link]("[1] Submit Attendance [2] Cancel");

[Link]("Choose an option: ");

int choice = [Link]([Link]());

if (choice != 1) {

[Link]("Cancelled.");

return;

int present = 0;

int absent = 0;

for (Player p : activePlayers) {

boolean isPresent = );

if (isPresent) {

present++;

} else {

absent++;

[Link](trainingId);

[Link]([Link]());

[Link](isPresent);
 [Link](a);

[Link]("Output:");

[Link]("Training attendance was recorded successfully.");

[Link]("Summary:");

[Link]("Present: " + present);

[Link]("Absent: " + absent);

[Link]("Attendance recorded successfully.");

package manager;

import [Link];

import [Link];

import [Link];

import static [Link].VALID_MATCHTYPE;

import [Link];

public class MatchManager {

private ArrayList<MatchRecord> matchList = new ArrayList<>();

private Scanner sc = new Scanner([Link]);

private MatchRecord m = new MatchRecord();

public MatchManager() {
}

public boolean isMatchIdUnique(String matchId) {

for (MatchRecord m : matchList) {

if ([Link]().equalsIgnoreCase(matchId)) {

return false;

return true;

public boolean isValidMatchType(String matchType) {

for (String t : VALID_MATCHTYPE) {

if ([Link](matchType)) {

return true;

return false;

public void createMatchRecord() {

[Link]("===== CREATE MATCH RECORD =====");

String matchId;

String date;

String opponentTeam;

String matchType;

do {
 [Link]("Match ID: ");

matchId = [Link]().trim();

if ([Link]()) {

[Link]("Match ID cannot be empty!");

continue;

if (!isMatchIdUnique(matchId)) {

[Link]("Match ID already exists!");

continue;

break;

} while (true);

do {

[Link]("Date: ");

date = [Link]().trim();

if ([Link]()) {

[Link]("Date cannot be empty!");

continue;

break;

} while (true);

do {

[Link]("Opponent Team: ");

 opponentTeam = [Link]().trim();

if ([Link]()) {

[Link]("Opponent Team cannot be empty!");

continue;

break;

} while (true);

do {

[Link]("Match Type:");

[Link]("1. Friendly");

[Link]("2. League");

[Link]("3. Cup");

[Link]("Choose Match Type: ");

int choice = [Link]([Link]());

if (choice == 1) {

matchType = "Friendly";

break;

} else if (choice == 2) {

matchType = "League";

break;

} else if (choice == 3) {

matchType = "Cup";

break;
 } else {

[Link]("Please choose 1, 2, or 3!");

} while (true);

[Link](matchId);

[Link](opponentTeam);

[Link](date);

[Link](matchType);

[Link](m);

[Link]("Match record created successfully!");

public void searchById() {

int flag = 0;

[Link]("Enter match id to search: ");

String matchId = [Link]();

[Link]("Search Result: ");

for (MatchRecord m : matchList) {

if ([Link]().equalsIgnoreCase(matchId)) {

[Link]("Match ID: %s\nDate: %s\nOpponent Team: %s\

nMatch Type: %s", [Link](),

[Link](), [Link](), [Link]());

flag = 1;

if (flag == 0) {

[Link]("Not found!!!");
 }

public void viewMatchHistory() {

[Link]("-----------TRAINING HISTORY-----------");

[Link]("%-6s%-12s%-23s%-23s", "ID", "Date", "Opponent

Team", "Match Type");

[Link]("-------------------------------------------------------------");

[Link]("%-6s%-12s%-23s%-23s", [Link](),
[Link](), [Link](), [Link]());

[Link]("-------------------------------------------------------------");

package manager;

import [Link];

import [Link];

import [Link];

public class PerformanceManager {

private ArrayList<PerformanceRecord> performanceList = new

ArrayList<>();

private Scanner sc = new Scanner([Link]);

public ArrayList<PerformanceRecord> getPerformanceList() {

return performanceList;
 }

public PerformanceManager(ArrayList<PerformanceRecord>
performanceList) {

[Link] = performanceList;

public PerformanceManager() {

public PerformanceRecord findPerformance() {

[Link]("Enter Match ID: ");

String matchId = [Link]();

[Link]("Enter Player ID: ");

String playerId = [Link]();

for (PerformanceRecord p : performanceList) {

if ([Link]().equalsIgnoreCase(matchId) &&
[Link]().equalsIgnoreCase(playerId)) {

return p;

return null;

//dùng cho salaryManager

 public PerformanceRecord findPerformanceByPlayerId(String playerId) {

for (int i = 0; i < [Link](); i++) {

if ([Link](i).getPlayerId().equalsIgnoreCase(playerId)) {

return [Link](i);

return null;

public void addPerformance() {

PerformanceRecord record = new PerformanceRecord();

[Link]("Enter Match ID: ");

String matchId = [Link]();

[Link]("Enter Player ID: ");

String playerId = [Link]();

// Kiểm tra trùng

for (PerformanceRecord p : performanceList) {

if ([Link]().equalsIgnoreCase(matchId) &&
[Link]().equalsIgnoreCase(playerId)) {

[Link]("Performance record already exists!");

return;

[Link]("Goals: ");
 int goals = [Link]([Link]());

[Link]("Assists: ");

int assists = [Link]([Link]());

[Link]("Yellow Cards: ");

int yellowCards = [Link]([Link]());

[Link]("Red Cards: ");

int redCards = [Link]([Link]());

[Link]("Minutes Played: ");

int minutesPlayed = [Link]([Link]());

[Link](matchId);

[Link](playerId);

[Link](goals);

[Link](assists);

[Link](yellowCards);

[Link](redCards);

[Link](minutesPlayed);

[Link](record);

[Link]("Add successfully!");

[Link]("Performance Points: " +

[Link]());

public void updatePerformance() {

PerformanceRecord p = findPerformance();

if (p == null) {
 [Link]("Performance record not found!");

return;

[Link]("New Goals: ");

int goals = [Link]([Link]());

[Link]("New Assists: ");

int assists = [Link]([Link]());

[Link]("New Yellow Cards: ");

int yellowCards = [Link]([Link]());

[Link]("New Red Cards: ");

int redCards = [Link]([Link]());

[Link]("New Minutes Played: ");

int minutesPlayed = [Link]([Link]());

[Link](goals);

[Link](assists);

[Link](yellowCards);

[Link](redCards);

[Link](minutesPlayed);

[Link]("Update successfully!");

[Link]("Performance Points: " +

[Link]());

}
package manager;

import [Link];

import [Link];

import [Link];

import static [Link].STATUS_ACTIVE;

import static [Link].STATUS_INACTIVE;

import static [Link].VALID_POSITIONS;

import [Link];

import [Link];

public class PlayerManager {

private ArrayList<Player> players = new ArrayList<>();

private Scanner sc = new Scanner([Link]);

private Player p;

public PlayerManager(ArrayList<Player> players) {

[Link] = players;

public PlayerManager() {

//BR1: ID unique

public boolean isIdUnique(String id) {

for (Player p : players) {

 if ([Link]().equalsIgnoreCase(id)) {

return false;

return true;

// BR6: Active players cannot share shirt number

public boolean isDuplicateShirtNumber(int shirtNumber) {

for (Player p : players) {

if ([Link]() && [Link]() == shirtNumber) {

return true;

return false;

//BR10:

public void deletePlayer() {

[Link]("Enter player Id to delete: ");

String deleteId = [Link]();

for (Player p : players) {

if ([Link]().equalsIgnoreCase(deleteId)) {

[Link](Player.STATUS_INACTIVE);

[Link]("Successfully!");
 }

public void addPlayer() {

p = new Player();

input();

[Link](p);

[Link]("Player added successfully!");

public void searchById() {

[Link]("Enter Player ID: ");

String searchId = [Link]();

int flag = 0;

[Link]("Search Result:");

[Link]("%-6s%-18s%-5s%-10s%-7s%-16s%-8s\n", "ID",
"Name", "Age", "Position", "Shirt", "Type", "Status");

[Link]("-------------------------------------------------------------------------------
-------");

for (Player p : players) {

if ([Link]().equalsIgnoreCase(searchId)) {

[Link]("%-6s%-18s%-5d%-10s%-7d%-16s%-8s\n",
[Link](), [Link](),

[Link](), [Link](), [Link](),

[Link](), [Link]());

flag = 1;

}
 if (flag == 0) {

[Link]("Not found!!!");

//hàm search này dùng riêng cho salaryManagement, do hàm searchById

không return object -- Phong fix

public Player findPlayerById(String id) {

for (int i = 0; i < [Link](); i++) {

if ([Link](i).getPlayerId().equalsIgnoreCase(id)) {

return [Link](i);

return null;

public void updatePlayer() {

[Link]("Enter Player ID to update: ");

String updateId = [Link]();

Player found = findPlayerById(updateId);

if (found == null) {

[Link]("Not found!!!");

return;

}
 [Link]("Current Information:");

[Link]("Name: " + [Link]()

+ " | Position: " + [Link]()

+ " | No." + [Link]());

[Link]("Base Salary: " + [Link]("%.0f",

[Link]())

+ " | Type: " + [Link]()

+ " | Status: " + [Link]());

[Link]("Update player information:");

String position;

int shirtNumber;

double baseSalary;

String status;

//position

do {

[Link]("Enter new Position: ");

position = [Link]().trim();

if ([Link]()) {

[Link]("New Position cannot be empty!");

continue;

if () {
 [Link]("Please enter Position (Goalkeeper, Defender,
Midfielder, Forward)!");

continue;

break;

} while (true);

//shirtNumber

do {

try {

[Link]("Enter new Shirt Number: ");

shirtNumber = [Link]([Link]());

if (shirtNumber < 1 || shirtNumber > 99) {

[Link]("Shirt number must be between 1 and 99!");

continue;

if ([Link]() && isDuplicateShirtNumber(shirtNumber)) {

[Link]("Another active player already uses this shirt

number!");

continue;

break;

} catch (NumberFormatException e) {

[Link]("Invalid shirt number!");

}
 } while (true);

//salary

do {

try {

[Link]("Enter Base Salary: ");

baseSalary = [Link]([Link]());

if (baseSalary < 0) {

[Link]("Shirt number must be greater than zero!");

continue;

break;

} catch (NumberFormatException e) {

[Link]("Invalid shirt number!");

} while (true);

//status

do {

[Link]("Enter Status (Active/Inactive): ");

status = [Link]().trim();

if ( && !
[Link](STATUS_INACTIVE)) {

[Link]("Status must be Active or Inactive!");

}
 } while ( && !
[Link](STATUS_INACTIVE));

[Link](position);

[Link](shirtNumber);

[Link](baseSalary);

[Link](status);

[Link]("Player updated successfully!");

public void input() {

String playerId, fullName, nationality, position, playerType, status;

int age, shirtNumber;

double baseSalary;

Scanner sc = new Scanner([Link]);

//playerId

do {

[Link]("Enter Player ID: ");

playerId = [Link]().trim();

if ([Link]()) {

[Link]("Player ID cannot be empty!");

continue;

if (!isIdUnique(playerId)) {

[Link]("Player ID already exists!");

 continue;

break;

} while (true);

//fullName

do {

[Link]("Enter Full Name: ");

fullName = [Link]().trim();

if ([Link]()) {

[Link]("Full name cannot be empty!");

} while ([Link]());

//age

do {

try {

[Link]("Enter Age: ");

age = [Link]([Link]());

if (age < 16 || age > 45) {

[Link]("Player age must be between 16 and 45!");

continue;

break;

} catch (NumberFormatException e) {
 [Link]("Invalid player age!");

} while (true);

//nationality

do {

[Link]("Enter Nationality: ");

nationality = [Link]().trim();

if ([Link]()) {

[Link]("Nationality cannot be empty!");

} while ([Link]());

//position

do {

[Link]("Enter Position (Goalkeeper, Defender, Midfielder,

Forward): ");

position = [Link]().trim();

if ([Link]()) {

[Link]("Position cannot be empty!");

continue;

if () {
 [Link]("Please enter Position (Goalkeeper, Defender,
Midfielder, Forward)!");

continue;

break;

} while (true);

//shirtNumber

do {

try {

[Link]("Enter Shirt Number: ");

shirtNumber = [Link]([Link]());

if (shirtNumber < 1 || shirtNumber > 99) {

[Link]("Shirt number must be between 1 and 99!");

continue;

if ([Link]() && isDuplicateShirtNumber(shirtNumber)) {

[Link]("Another active player already uses this shirt

number!");

continue;

break;

} catch (NumberFormatException e) {

[Link]("Invalid shirt number!");

}
} while (true);

//baseSalary

do {

try {

[Link]("Enter Base Salary: ");

baseSalary = [Link]([Link]());

if (baseSalary < 0) {

[Link]("Shirt number must be greater than zero!");

continue;

break;

} catch (NumberFormatException e) {

[Link]("Invalid shirt number!");

} while (true);

//playerType

int choice;

do {

try {

[Link]("===== PLAYER TYPE =====");

[Link]("1. Regular Player");

[Link]("2. Star Player");

[Link]("Choose player type: ");

choice = [Link]([Link]());
 if (choice == 1 || choice == 2) {

break;

[Link]("Please choose 1 or 2!");

} catch (NumberFormatException e) {

[Link]("Invalid input!");

} while (true);

if (choice == 1) {

[Link]("Regular Player");

} else {

[Link]("Star Player");

//status

do {

[Link]("Enter Status (Active/Inactive): ");

status = [Link]().trim();

if ( && !
[Link](STATUS_INACTIVE)) {

[Link]("Status must be Active or Inactive!");

} while ( && !

[Link](STATUS_INACTIVE));
 [Link](playerId);

[Link](fullName);

[Link](age);

[Link](nationality);

[Link](position);

[Link](shirtNumber);

[Link](baseSalary);

[Link](status);

public void viewPlayerDetails() {

[Link]("------------- PLAYER DETAILS --------------");

[Link]("Enter Player ID: ");

String detailId = [Link]();

[Link]("");

Player found = findPlayerById(detailId);

if (found == null) {

[Link]("Not found!!!");

return;

[Link]();

public void viewAllPlayers() {

[Link]("---------------PLAYER LIST------------------");
 [Link]("%-6s%-18s%-5s%-10s%-7s%-16s%-8s\n", "ID",
"Name", "Age", "Position", "Shirt", "Type", "Status");

[Link]("-------------------------------------------------------------------------------
-------");

for (Player p : players) {

[Link]("%-6s%-18s%-5d%-10s%-7d%-16s%-8s\n",
[Link](), [Link](),

[Link](), [Link](), [Link](),

[Link](), [Link]());

public ArrayList<Player> getActivePlayers() {

ArrayList<Player> result = new ArrayList<>();

for (Player p : players) {

if ([Link]()) {

[Link](p);

return result;

public ArrayList<Player> getPlayers() {

return players;

}
package manager;

import [Link];

import [Link];

import [Link];

import [Link];

public class ReportManager {

private ArrayList<Player> players = new ArrayList<>();

private ArrayList<SalaryRecord> salaryRecords = new ArrayList<>();

private ArrayList<PerformanceRecord> performanceRecords = new

ArrayList<>();

public ReportManager(ArrayList<Player> players,

ArrayList<SalaryRecord> salaryRecords,

ArrayList<PerformanceRecord> performanceRecords) {

[Link] = players;

[Link] = salaryRecords;

[Link] = performanceRecords;

public void salarySummaryReport() {

[Link]("\n========== SALARY SUMMARY REPORT

==========");

[Link]("%-10s %-20s %-8s %-8s %-15s %-15s %-15s\n",

"PlayerID",

"Name", "Month", "Year", "BaseSalary", "Bonus", "TotalSalary");

 for (SalaryRecord sr : salaryRecords) {

String playerName = "";

for (Player p : players) {

if ([Link]().equalsIgnoreCase([Link]())) {

playerName = [Link]();

break;

[Link]("%-10s %-20s %-8d %-8d %-15.0f %-15.0f %-15.0f\

n", [Link](), playerName,

[Link](), [Link](), [Link](), [Link](),

[Link]());

public void allTimeTopGoalScorers() {

[Link]("\n========== ALL-TIME TOP GOAL SCORERS

==========");

[Link]("%-10s %-20s %-10s\n", "PlayerID", "Name", "Goals");

for (Player p : players) {

int totalGoals = 0;

for (PerformanceRecord pr : performanceRecords) {

if ([Link]().equalsIgnoreCase([Link]())) {

totalGoals += [Link]();

}
 [Link]("%-10s %-20s %-10d\n", [Link](),
[Link](), totalGoals);

package manager;

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class SalaryManager {

private ArrayList<SalaryRecord> salaryRecords;

private PlayerManager pm;

private PerformanceManager performanceManager;

public SalaryManager(PlayerManager pm, PerformanceManager

performanceManager, ArrayList<SalaryRecord> salaryRecords) {

[Link] = pm;

[Link] = performanceManager;

[Link] = salaryRecords;

}
 public SalaryManager() {

public double calculateBonus(int performancePoints) {

return performancePoints * 500000;

public double totalSalary(Player player, int performancePoints) {

return [Link]() + calculateBonus(performancePoints);

public void calculatePlayerSalary() {

Scanner sc = new Scanner([Link]);

[Link]("---------------- CALCULATE PLAYER SALARY

----------------");

[Link]("Enter Month: ");

int month = [Link]([Link]());

[Link]("Enter Year: ");

int year = [Link]([Link]());

[Link]("Enter Player ID: ");

String playerId = [Link]().trim();

Player found = [Link](playerId);

if (found == null) {
 [Link]("Player not found!");

return;

PerformanceRecord pr =
[Link](playerId);

if (pr == null) {

[Link]("Performance record not found!");

return;

int points = [Link]();

double bonus = calculateBonus(points);

double total = totalSalary(found, points);

SalaryRecord sr = new SalaryRecord([Link](), month, year,

[Link](), bonus);

[Link](sr);

[Link]("Player: " + [Link]());

[Link]("Type: " + [Link]());

[Link]("Base Salary: " + [Link]("%.0f",

[Link]()));

[Link]("Monthly Performance Points: " + points);

[Link]("Output:");

[Link]("Salary Summary:");

[Link]("Base Salary: " + [Link]("%.0f",

[Link]()) + " VND");

[Link]("Performance Bonus: " + [Link]("%.0f",

bonus) + " VND");
 [Link]("Total Salary: " + [Link]("%.0f", total) + "
VND");

package manager;

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];

public class TrainingManager {

private ArrayList<TrainingSession> trainings = new ArrayList<>();

private Scanner sc = new Scanner([Link]);

private TrainingSession t = new TrainingSession();

public TrainingManager() {

public TrainingManager(ArrayList<TrainingSession> trainings) {

[Link] = trainings;

public boolean isTrainingUnique(String id) {

 for (TrainingSession t : trainings) {

if ([Link]().equalsIgnoreCase(id)) {

return false;

return true;

public void searchTrainingById() {

[Link]("Enter training id to search: ");

String trainingId = [Link]();

int flag = 0;

[Link]("Search Result:");

[Link]("%-6s%-12s%-23s%-23s", "ID", "Date", "Location",

"Topic");

for (TrainingSession t : trainings) {

if ([Link]().equalsIgnoreCase(trainingId)) {

[Link]("%-6s%-12s%-23s%-23s", [Link](),
[Link](), [Link](), [Link]());

flag = 1;

if (flag == 0) {

[Link]("Not found!!!");

}
public void createTrainingSession() {

[Link]("-------------CREATE TRAINING SESSION---------------");

String trainingId, location, topic, date;

//trainingid

do {

[Link]("Enter Training ID: ");

trainingId = [Link]().trim();

if ([Link]()) {

[Link]("Training ID cannot be empty!");

continue;

if (!isTrainingUnique(trainingId)) {

[Link]("Training ID already exists!");

continue;

break;

} while (true);

//date

do {

[Link]("Enter Date: ");

date = [Link]().trim();

if ([Link]()) {

[Link]("Date cannot be empty!");

continue;
 }

break;

} while (true);

//location

do {

[Link]("Enter Location: ");

location = [Link]().trim();

if ([Link]()) {

[Link]("Location cannot be empty!");

continue;

break;

} while (true);

//topic

do {

[Link]("Enter Training Topic: ");

topic = [Link]().trim();

if ([Link]()) {

[Link]("Topic cannot be empty!");

continue;

break;

} while (true);
 [Link](trainingId);

[Link](date);

[Link](location);

[Link](topic);

[Link](t);

[Link]("Training session create succesfully!");

public void viewTrainingHistory() {

[Link]("-----------TRAINING HISTORY-----------");

[Link]("%-6s%-12s%-23s%-23s", "ID", "Date", "Location",

"Topic");

[Link]("-------------------------------------------------------------");

[Link]("%-6s%-12s%-23s%-23s", [Link](),
[Link](), [Link](), [Link]());

[Link]("-------------------------------------------------------------");