本平台根据角色定位不同有不同的模块，首先系统有一个登录注册模块，属于兼职人员的模块有个人信息管理和兼职申请；属于管理员的模块有基本信息维护、兼职信息投放和系统管理。
功能结构图：
项目功能如下：
（1）登录注册功能：用户通过注册进入平台，注册信息包括用户编号（用户编号决定角色类型，学号注册为兼职人员，教师编号注册为管理员），注册后到登录界面输入账号和密码登录平台，注册信息包括：用户编号（学号/教师编号）、密码、姓名、出生日期、性别、电话、所在院系、注册日期等。后期如果忘记了密码，用户通过自己的账号和注册时的姓名找回密码。注意，为了安全起见，只有已经录入系统的用户可以注册账户，本平台提前录入了部分管理员和学生的信息到系统中供大家注册。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
（2）个人信息管理：包括个人信息修改、密码修改、查询信用等级和查询余额功能。普通用户登录成功之后，可以修改个人注册时录入的信息，学号和注册时间不可更改，密码单独修改；也可以查询个人的信用等级，若信用等级不是最高，则查询个人信用等级时附加显示“按时完成X次后信用等级恢复至X级”（默认未逾期完成兼职工作3次恢复1级信用等级，等级梯度为1-5级，5级最高）。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
（3）兼职申请功能：包括兼职信息查询、申请工作和结束工作。用户登录成功之后，可以查询所有的兼职信息，包括自己能申请的职位和不能申请的职位，也可以只查看自己能申请的职位（是否可申请与信用等级、岗位所需人员、兼职时间相关）。用户还可查看自己已完成的兼职信息和自己正在完成的兼职信息。满足条件的兼职，用户可以申请，开始工作时间为系统当前时间，相对的该兼职岗位对应的所需人员需要减少；完成工作后（逾期完成信用自动降低1级，0级为最低，0级后不可再申请兼职工作），需要计算所得薪酬（所得薪酬和是否逾期、逾期天数相关），若未逾期且信用等级未满，则需要计算恢复信用等级所需的次数，完成时间手动输入，不可小于兼职开始时间。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
（4）基本信息维护功能：包括兼职等级设置、用户信用调整和逾期费用扣除比例调整。管理员端登录成功之后，可以调整兼职的等级（兼职等级梯度为一-五级，五级最高，一级最低），普通用户的信用等级>=兼职等级可申请职位，还可以增删兼职的类型，比如开发外包/销售/设计师等。管理员可以根据用户的表现动态地调整用户的信用等级，可越级增减，0级信用的普通用户管理员不可调整其信用等级。管理员还可以调整兼职的逾期费用，每天逾期扣除的费用相同，比如：原定一份兼职总薪资1000元，工作要求10天完成，逾期1天扣除100元，调整后一天扣除200元（扣除兼职费用为0后继续扣除用户余额，直到用户余额为<=0，自动结束工作，结算费用）。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
（5）兼职信息投放：包括兼职人员设置、兼职的金额设置、兼职的时间录入以及兼职的其他信息录入。系统管理员登录成功之后可以把所有公司发布的兼职信息录入到平台，录入信息包括：营业执照编号、公司名字、岗位名称、兼职类型、兼职等级、工作内容、需求人数、工作时间等。系统管理员可以根据市场和公司要求，动态调整这些兼职工作的部分内容，比如需求人数、薪水等，工作时间不允许更改。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
（6）系统管理功能：包括对普通用户、管理员和兼职信息的增删查改等。系统提前录入了一些管理员或者学生的信息在系统中，但是未全部录入，所以后续需要注册的用户需要已经录入的管理员登录平台进行信息录入，系统录入仅需要学号/教师编号和姓名即可，此信息供用户注册使用。管理员可以删除普通用户和别的管理员，以及没有用的兼职信息。（相关存储数据可通过I/O流直接存在文件，可也直接在文件里读的数据）
原码如下：
包括四个实体类：Job,JobType,User,UserAccount
Job类：
package campusjobplatform.view;
import campusjobplatform.servise.ApplyJobService;
import campusjobplatform.servise.BaseMessageService;
import campusjobplatform.servise.JobService;
import campusjobplatform.servise.UserService;
import java.io.IOException;
import java.text.ParseException;
public class IndexView {
private LoginView loginVi = new LoginView();
private UserService usc=new UserService();
private JobService jobSvc=new JobService();
private ApplyJobService ajSvc=new ApplyJobService();
private BaseMessageService bmSvc=new BaseMessageService();
public void menu() throws IOException, ParseException {
System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
System.out.println("🔣 🔣");
System.out.println("🔣 欢迎来到校园兼职平台 🔣");
System.out.println("🔣 🔣");
System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
System.out.println("🐕");
TSUtility.readReturn();
do {
System.out.println("🐕-----------<请您先登录平台>---------------🐕");
System.out.println("🐕------------1.注册--------------🐕");
System.out.println("🐕------------2.登录--------------🐕");
System.out.println("🐕-----------3.找回密码------------🐕");
System.out.println("🐕-----------4.退出系统------------🐕");
System.out.println("请选择：");
char c=TSUtility.readMenuSelection1();
if (c == '1') {
loginVi.register();
continue;
} else if (c == '2') {
loginVi.logIn();
}else if (c == '3') {
usc.findPassword(loginVi.getUsers());
continue;
}else {
return;
}
System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
System.out.println("🔣 🔣");
System.out.println("🔣 ~校园兼职平台主菜单~ 🔣");
System.out.println("🔣 🔣");
System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
int length=loginVi.getUser().getUserId().length();
boolean loopFlag1=false;
boolean loopFlag2=false;
if (length==5) {
loopFlag1=true;
}else {
loopFlag2=true;
}
System.out.println("⬇请选择： ");
while (loopFlag1) {
System.out.println("🐻1. <个人信息管理> *");
System.out.println("🐘2. <兼职申请> *");
System.out.println("🦊3. <返回登录界面> *");
char c1=TSUtility.readMenuSelection3();
switch (c1) {
case '1':
boolean loopFlag3=true;
while (loopFlag3) {
System.out.println("1.修改个人信息");
System.out.println("2.修改密码");
System.out.println("3.查询信用等级");
System.out.println("4.查询余额");
System.out.println("5.返回上级菜单");
char c11 = TSUtility.readMenuSelection2();
switch (c11) {
case '1':
usc.modifyUser(loginVi.getUsers());
break;
case '2':
usc.modifyPassword(loginVi.getUsers(), loginVi.getUser());
break;
case '3':
usc.queryCredit_Rating(loginVi.getUser());
break;
case '4':
usc.queryBalance(loginVi.getUser());
break;
case '5':
loopFlag3 = false;
}
}
break;
case '2':
boolean loopFlag4=true;
while (loopFlag4){
System.out.println("1.查询所有兼职信息");
System.out.println("2.查询可申请兼职信息");
System.out.println("3.职位申请");
System.out.println("4.结束工作");
System.out.println("5.查询正在完成的兼职");
System.out.println("6.查询已完成兼职");
System.out.println("7.返回上级菜单");
char c21=TSUtility.readMenuSelection4();
switch (c21){
case '1':
ajSvc.showAllJobs();
break;
case '2':
ajSvc.showMyJobs(loginVi.getUser());
break;
case '3':
ajSvc.applyJob(loginVi.getUser());
break;
case '4':
ajSvc.endJob(loginVi.getUser());
break;
case '5':
ajSvc.showMyFinishingJob(loginVi.getUser());
break;
case '6':
ajSvc.showMyFinishedJob(loginVi.getUser());
case '7':
loopFlag4=false;
}
}
break;
case '3':
loopFlag1=false;
}
}
while (loopFlag2){
System.out.println("🐻1. <基本信息维护> *");
System.out.println("🐘2. <兼职信息投放> *");
System.out.println("🐘3. <系统管理> *");
System.out.println("🦊4. <返回登录界面> *");
char c2=TSUtility.readMenuSelection1();
switch (c2){
case '1':
boolean loopFlag5=true;
while (loopFlag5) {
System.out.println("1.兼职等级设置");
System.out.println("2.兼职类型设置");
System.out.println("3.用户信用调整");
System.out.println("4.逾期费用扣除比例调整");
System.out.println("5.返回上级菜单");
char c11= TSUtility.readMenuSelection2();
switch (c11){
case '1':
bmSvc.setJobLevel(ajSvc.getJobs());
break;
case '2':
System.out.println("1.增加工作类型");
System.out.println("2.删除工作类型");
System.out.println("3.查看所有工作类型");
char c3=TSUtility.readMenuSelection3();
switch (c3){
case '1':
bmSvc.addJobType(ajSvc.getJobTypes());
break;
case '2':
bmSvc.delJobType(ajSvc.getJobTypes());
break;
case '3':
bmSvc.showJobType(ajSvc.getJobTypes());
}
break;
case '3':
bmSvc.setUserCreditRating(loginVi.getUsers(), loginVi.getAccounts());
break;
case '4':
bmSvc.modifyDeductSalary(ajSvc.getJobTypes());
break;
case '5':
loopFlag5=false;
}
}
break;
case '2':
boolean loopFlag6=true;
while (loopFlag6){
System.out.println("1.兼职信息录入");
System.out.println("2.兼职信息修改");
System.out.println("3.返回上级菜单");
char c21=TSUtility.readMenuSelection3();
switch (c21){
case '1':
jobSvc.addJob(ajSvc.getJobs(), ajSvc.getJobTypes());
break;
case '2':
jobSvc.modifyJob(ajSvc.getJobs());
break;
case '3':
loopFlag6=false;
}
}
break;
case '3':
boolean loopFlag7=true;
while (loopFlag7) {
System.out.println("1.添加删除信息");
System.out.println("2.查询用户或职位信息");
System.out.println("3.人员录入");
System.out.println("4.返回上级菜单");
char c31=TSUtility.readMenuSelection1();
switch (c31) {
case '1':
System.out.println("1.删除用户");
System.out.println("2.删除兼职");
System.out.println("3.添加用户");
System.out.println("4.返回上级菜单");
char c4=TSUtility.readMenuSelection1();
switch (c4){
case '1':
usc.delUser(loginVi.getUsers(), loginVi.getUser());
break;
case'2':
jobSvc.delJob(ajSvc.getJobs());
break;
case '3':
loginVi.register();
break;
case '4':
break;
}
break;
case '2':
System.out.println("1.查询用户");
System.out.println("2.查询账户");
System.out.println("3.查询查询已投放职位");
System.out.println("4.查询已完成职位");
System.out.println("5.查询逾期职位");
char c5=TSUtility.readMenuSelection2();
switch (c5){
case '1':
usc.findUser(loginVi.getUsers());
break;
case '2':
usc.findAccount(loginVi.getAccounts());
break;
case '3':
ajSvc.showAllJobs();
break;
case '4':
ajSvc.showFinishedJobs();
break;
case '5':
ajSvc.showoverdueJobs();
}
break;
case '3':
loginVi.entrySystem();
break;
case '4':
loopFlag7=false;
}
}
break;
case '4':
loopFlag2=false;
}
}
}while (true);
}
public static void main(String[] args) throws IOException, ParseException {
new IndexView().menu();
}
}
User类：
package campusjobplatform.domain;
import java.io.Serial;
import java.io.Serializable;
import java.util.ArrayList;
public class User implements Serializable {
private String userId;
private String passWord;
private String name;
private int age;
private char gender;
private int telephone;
private String department;
private String regdat;
private int credit_rating=5;
private int balance=0;
private int times=0;
private ArrayList<Job> myJobs=new ArrayList<>();
@Serial
private static final long serialVersionUID = 42L;
public User() {
}
public User(String userId, String passWord, String name, int age, char gender, int telephone, String department) {
this.userId = userId;
this.passWord = passWord;
this.name = name;
this.age = age;
this.gender = gender;
this.telephone = telephone;
this.department = department;
}
public ArrayList<Job> getMyJobs() {
return myJobs;
}
public void setMyJobs(ArrayList<Job> myJobs) {
this.myJobs = myJobs;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getTelephone() {
return telephone;
}
public void setTelephone(int telephone) {
this.telephone = telephone;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public String getRegdat() {
return regdat;
}
public void setRegdat(String regdat) {
this.regdat = regdat;
}
public int getCredit_rating() {
return credit_rating;
}
public void setCredit_rating(int credit_rating) {
this.credit_rating = credit_rating;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
public int getTimes() {
return times;
}
public void setTimes(int times) {
this.times = times;
}
public String getUsers(){
return userId+"\t"+name+"\t"+passWord+"\t"+department;
}
@Override
public String toString() {
return "User{" +
"userId='" + userId + '\'' +
", passWord='" + passWord + '\'' +
'}';
}
}
TSUtility为工具类
LoginView用于注册登录功能实现
IndexView实现了主页面菜单
UserService类包括了关于用户信息的增删改查功能
UserService：
package campusjobplatform.servise;
import campusjobplatform.domain.User;
import campusjobplatform.domain.UserAccount;
import campusjobplatform.view.TSUtility;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class UserService {
//修改用户信息
public void modifyUser(ArrayList<User> users) throws IOException {
while (true) {
System.out.println("请输入你需要修改的用户id：");
String userId= TSUtility.readUserID();
for (int i = 0; i < users.size(); i++) {
if (userId.equals(users.get(i).getUserId())) {
User user= users.get(i);
System.out.print("请输入您的姓名(按下Enter代表不修改)：");
String name= TSUtility.readString(4,user.getName());
System.out.print("请输入您的年龄(按下Enter代表不修改)：");
int age= TSUtility.readInt(2,user.getAge());
System.out.print("请输入您的性别(按下Enter代表不修改)：");
char gender=TSUtility.setGender(user.getGender());
System.out.print("请输入您的手机号码(按下Enter代表不修改)：");
int telephone=TSUtility.readInt(11,user.getTelephone());
user.setName(name);
user.setAge(age);
user.setGender(gender);
user.setTelephone(telephone);
users.set(i,user);
System.out.println("修改用户成功！");
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src\\campusjobplatform\\files\\registerusers.txt"));
for (int j = 0; j < users.size(); j++) {
oos.writeObject(users.get(j));
}
oos.close();
String filename="src\\campusjobplatform\\files\\journal.txt";
String s=userId+"已修改用户信息";
TSUtility.writeJournal(filename,s);
return;
}
}
System.out.println("您输入的用户名不存在，请重新输入：");
}
}
//删除用户
public void delUser(ArrayList<User> users,User user) throws IOException {
while (true) {
System.out.println("请输入你需要删除的用户id：");
String userId = TSUtility.readUserID();
if (userId.equals(user.getUserId())){
System.out.println("不能删除已经登录的用户！");
return;
}
System.out.println("是否删除此用户？(Y/N)");
if (TSUtility.readConfirmSelection()) {
for (int i = 0; i < users.size(); i++) {
if (userId.equals(users.get(i).getUserId())) {
users.remove(i);
System.out.println("用户删除成功！");
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("src\\campusjobplatform\\files\\registerusers.txt"));
for (int j = 0; j < users.size(); j++) {
oos.writeObject(users.get(j));
}
oos.close();
String filename="src\\campusjobplatform\\files\\journal.txt";
String s="已删除用户:"+userId;
TSUtility.writeJournal(filename,s);
return;
}
}
System.out.println("您输入的用户不存在，请重新输入");
}
}
}
//查看指定用户
public void findUser(ArrayList<User> users){
boolean flag=false;
System.out.println("请输入需要查看的用户id：");
String userId=TSUtility.readUserID();
System.out.println("学号/教师编号\t姓名\t密码\t院系");
for (User user:users){
if (user.getUserId().equals(userId))
System.out.println(user);
flag=true;
break;
}
if (!flag) {
System.out.println("该用户不存在！");
}
}
//查看指定用户账户
public void findAccount(HashMap<String, UserAccount> accounts){
System.out.println("请输入查询账户对应的用户id：");
String userId= TSUtility.readUserID();
Set<String> keySet = accounts.keySet();
System.out.println("用户id\t账户\t信用等级\t余额");
for (String key:keySet){
if (userId.equals(key)){
System.out.println(key+"\t"+accounts.get(key));
}
}
}
//找回密码
public void findPassword(ArrayList<User> users) throws IOException {
System.out.println("请输入您的学号/教师编号：");
String userId=TSUtility.readUserID();
System.out.println("请输入您的姓名：");
String name= TSUtility.readKeyBoard(4,false);
for (int i = 0; i < users.size(); i++) {
String password="";
if (userId.equals(users.get(i).getUserId())&&name.equals(users.get(i).getName())) {
System.out.println("请输入新的密码：");
password=TSUtility.readPasWord();
while (true) {
System.out.println("请确认您的新密码：");
String pas = TSUtility.readPasWord();
if (password.equals(pas)) {
users.get(i).setPassWord(password);
System.out.println("修改密码成功！");
String filename="src\\campusjobplatform\\files\\registerusers.txt";
TSUtility.mySerializable(users,filename);
String filename2="src\\campusjobplatform\\files\\journal.txt";
String s ="用户:"+userId+"找回密码";
TSUtility.writeJournal(filename2,s);
return;
} else {
System.out.println("您第二次输入的密码与第一次不相同，请重新输入：");
}
}
}
}
System.out.println("您输入的学号/教师编号或姓名不正确！");
}
//修改密码
public void modifyPassword(ArrayList<User> users,User user) throws IOException {
System.out.println("请输入您的密码：");
String passWord= TSUtility.readPasWord();
if (passWord.equals(user.getPassWord())){
System.out.println("请输入新的密码(回车代表不修改)：");
String pw= TSUtility.readPasWord(passWord);
if (!(pw.equals(passWord))){
System.out.println("修改密码成功!");
}else {
return;
}
user.setPassWord(pw);
for (int i = 0; i < users.size(); i++) {
if (user.getUserId().equals(users.get(i).getUserId())){
users.set(i,user);
String filename="src\\campusjobplatform\\files\\registerusers.txt";
TSUtility.mySerializable(users,filename);
String filename2="src\\campusjobplatform\\files\\journal.txt";
String s="用户:"+user.getUserId()+"修改密码";
TSUtility.writeJournal(filename2,s);
}
}
}else {
System.out.println("您输入的密码不正确！");
}
}
//余额查询
public void queryBalance(User user){
System.out.println("您的余额为："+user.getBalance());
}
//信用等级查询
public void queryCredit_Rating(User user) throws IOException {
System.out.println("您目前的信用等级为："+user.getCredit_rating());
if (user.getCredit_rating()<5) {
System.out.println("按时完成" + (3 - user.getTimes()) + "次后信用等级恢复至" + (user.getCredit_rating() + 1));
}else {
System.out.println("您的信用已满级");
}
}
}
JobService包括对兼职信息的录入，修改删除
BaseMessageService类用于增删工作类型，调整工作等级和用户信用等级等
ApplyJobService类用于申请结束工作功能的实现
ApplyJobService：
package campusjobplatform.servise;
import campusjobplatform.domain.*;
import campusjobplatform.view.TSUtility;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Serial;
import java.io.Serializable;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
public class ApplyJobService implements Serializable {
private String UID;
private int JID;//三位数字
private String work_start;
private String work_end;
private double job_time;
private static ArrayList<JobType> jobTypes;
private static ArrayList<Job> jobs;
private static ArrayList<ApplyJobService> applyJobs;
private static ArrayList<Job> overdueJobs;
@Serial
private static final long serialVersionUID = 42L;
static {
String filename1="src\\campusjobplatform\\files\\jobtypes.txt";
String filename2="src\\campusjobplatform\\files\\jobs.txt";
String filename3="src\\campusjobplatform\\files\\applyjobs.txt";
String filename4="src\\campusjobplatform\\files\\overduejobs.txt";
try {
Object o = TSUtility.myDeserializable(filename1);
if (o==null){
jobTypes=new ArrayList<>();
}else {
jobTypes = (ArrayList<JobType>) TSUtility.myDeserializable(filename1);
}
o=TSUtility.myDeserializable(filename2);
if (o==null){
jobs=new ArrayList<>();
}else {
jobs=(ArrayList<Job>) TSUtility.myDeserializable(filename2);
}
o=TSUtility.myDeserializable(filename3);
if (o==null){
applyJobs=new ArrayList<>();
}else {
applyJobs=(ArrayList<ApplyJobService>) TSUtility.myDeserializable(filename3);
}
o=TSUtility.myDeserializable(filename4);
if (o==null){
overdueJobs=new ArrayList<>();
}else {
overdueJobs=(ArrayList<Job>) TSUtility.myDeserializable(filename4);
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
public ApplyJobService() {
}
public ApplyJobService(String UID, int JID, String work_start,double job_time) {
this.UID = UID;
this.JID = JID;
this.work_start = work_start;
this.job_time=job_time;
}
public String getUID() {
return UID;
}
public void setUID(String UID) {
this.UID = UID;
}
public int getJID() {
return JID;
}
public void setJID(int JID) {
this.JID = JID;
}
public String getWork_start() {
return work_start;
}
public void setWork_start(String work_start) {
this.work_start = work_start;
}
public String getWork_end() {
return work_end;
}
public void setWork_end(String work_end) {
this.work_end = work_end;
}
public ArrayList<JobType> getJobTypes() {
return jobTypes;
}
public void setJobTypes(ArrayList<JobType> jobTypes) {
this.jobTypes = jobTypes;
}
public ArrayList<Job> getJobs() {
return jobs;
}
public void setJobs(ArrayList<Job> jobs) {
this.jobs = jobs;
}
public double getJob_time() {
return job_time;
}
public void setJob_time(double job_time) {
this.job_time = job_time;
}
//查看所有兼职信息
public void showAllJobs(){
if (jobs.isEmpty()){
System.out.println("暂无兼职信息");
}else {
System.out.println("公司\t工作名\t工作等级\t薪资\t工作内容");
for (Job job : jobs) {
System.out.println(job);
}
}
}
//查看所有已完成工作
public void showFinishedJobs(){
boolean flag=false;
for (Job job:jobs){
if (job.getJob_demand()==0){
System.out.println(job);
flag=true;
}
}
if (!flag){
System.out.println("没有已完成的工作！");
}
}
//查看逾期工作
public void showoverdueJobs(){
System.out.println("公司\t工作名\t工作等级\t工作薪资\t工作内容");
if (overdueJobs.isEmpty()){
System.out.println("无逾期工作！");
}else {
for (Job job:overdueJobs){
System.out.println(job);
}
}
}
//查看自己能申请的岗位
public boolean showMyJobs(User user){
boolean flag=false;
System.out.println("兼职编号\t公司\t兼职名\t兼职等级\t薪水\t\t工作内容");
for (int i = 0; i < jobs.size(); i++) {
Job job= jobs.get(i);
if (user.getCredit_rating()>=job.getJob_level()&&job.getJob_demand()>0){
flag=true;
System.out.println(job);
}
}
if (!flag){
System.out.println("暂无可申请的工作！");
}
return flag;
}
//查看自己已完成的工作
public void showMyFinishedJob(User user){
boolean flag=false;
System.out.println("您已经完成的工作有：");
System.out.println("工作名称\t开始时间\t工作时间\t结束时间");
for (int i = 0; i < applyJobs.size(); i++) {
if (user.getUserId().equals(applyJobs.get(i).UID)){
if (!applyJobs.get(i).work_end.equals("")){
for (int j = 0; j < jobs.size(); j++) {
if (applyJobs.get(i).JID==jobs.get(j).getJID()){
String job_name=jobs.get(j).getJob_name();
String start_time=applyJobs.get(i).work_start;
String end_time=applyJobs.get(i).work_end;
double job_time=jobs.get(j).getJob_time();
System.out.println(job_name+"\t"+start_time+"\t"+job_time+"小时\t"+end_time);
flag=true;
}
}
}
}
}
if (!flag){
System.out.println("暂无正在完成的工作！");
}
}
//查看自己正在完成的工作
public void showMyFinishingJob(User user){
boolean flag=false;
System.out.println("您已经完成的工作有：");
System.out.println("工作名称\t开始时间\t工作时间");
for (int i = 0; i < applyJobs.size(); i++) {
if (user.getUserId().equals(applyJobs.get(i).UID)){
if (applyJobs.get(i).work_end.equals("")){
for (int j = 0; j < jobs.size(); j++) {
if (applyJobs.get(i).JID==jobs.get(j).getJID()){
String job_name=jobs.get(j).getJob_name();
String start_time=applyJobs.get(i).work_start;
double job_time=jobs.get(j).getJob_time();
System.out.println(job_name+"\t"+start_time+"\t"+job_time+"小时");
flag=true;
}
}
}
}
}
if (!flag){
System.out.println("没有已完成的工作！");
}
}
//比较时间，如果自己有正在完成的工作完成时间晚于想申请工作的开始时间则返回false
public boolean timeCompare(User user,String start_time) throws ParseException {
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm");
Date st=sdf.parse(start_time);
boolean isConflicting=true;
for (int i = 0; i < applyJobs.size(); i++) {
if (user.getUserId().equals(applyJobs.get(i).UID)) {
Date dd = sdf.parse(applyJobs.get(i).work_start);
Calendar cal = Calendar.getInstance();
cal.setTime(dd);
cal.add(Calendar.MINUTE, (int) (applyJobs.get(i).job_time * 60));
dd = cal.getTime();
if (st.before(dd)) {
isConflicting = false;
}
}
}
return isConflicting;
}
//申请工作
public void applyJob(User user) throws ParseException, IOException {
if (user.getCredit_rating()==0){
System.out.println("该用户信用等级已降至0，不可寻找兼职工作！");
return;
}
System.out.println("当前可选择工作如下：");
if (!showMyJobs(user)){
System.out.println("无法申请职位！");
return;
}
System.out.println("请输入需要申请的工作编号：");
Job job;
int JID= TSUtility.readInt(3);
boolean flag=false;
for (int i = 0; i < jobs.size(); i++) {
if (jobs.get(i).getJob_demand()>0) {
job = jobs.get(i);
}else {
continue;
}
if (user.getCredit_rating()<job.getJob_level()){
System.out.println("您的信用等级低于此工作等级，无法申请！");
return;
}
if (JID == job.getJID()) {
Date date=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm");
String start_time= sdf.format(date);
flag=true;
if (timeCompare(user,start_time)) {
user.getMyJobs().add(job);
jobs.get(i).setJob_demand(job.getJob_demand() - 1);
ApplyJobService AJSvc = new ApplyJobService(user.getUserId(), job.getJID(), start_time, job.getJob_time());
applyJobs.add(AJSvc);
System.out.println("申请工作成功！");
String filename="src\\campusjobplatform\\files\\applyjobs.txt";
TSUtility.mySerializable(applyJobs,filename);
String filename2="src\\campusjobplatform\\files\\journal.txt";
String s="用户"+user.getUserId()+"已申请工作："+JID;
TSUtility.writeJournal(filename2,s);
break;
}else {
System.out.println("您有正在完成的工作与该工作时间冲突！");
}
}
}
if (!flag){
System.out.println("未找到该工作！");
}
}
//获取一个工作扣除的费用
public int getDeduct_salary(ApplyJobService AJSvc,int deSalaryRate) throws ParseException {
int deSalary=0;
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm");
Date scheduleTime=sdf.parse(AJSvc.getWork_start());
Calendar c=Calendar.getInstance();
c.setTime(scheduleTime);
c.add(Calendar.MINUTE,(int)(AJSvc.getJob_time()*60));
Date d1=sdf.parse(AJSvc.getWork_end());//实际完成工作的时间
Date d2=c.getTime();//规定完成工作的时间
if (d1.after(c.getTime())){
double time=(d1.getTime()-d2.getTime())/(60*60*1000.0);
if (time<1){
deSalary=deSalaryRate;
}else {
deSalary=deSalaryRate*((int)time+1);
}
}
return deSalary;
}
//结束工作
public void endJob(User user) throws ParseException, IOException {
int jobId;
String work_end;
ApplyJobService AJSvc=null;
boolean flag=true;
int salary = 0;
while (flag) {
System.out.println("请输入需要完成的工作ID：");
jobId=TSUtility.readInt(3);
for (int i = 0; i < applyJobs.size(); i++) {
AJSvc = applyJobs.get(i);
if (user.getUserId().equals(AJSvc.UID) && jobId == AJSvc.JID) {
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm");
while (true) {
System.out.println("请输入您的完成工作时间(年-月-日 时:分)：");//如何限制格式？
work_end = TSUtility.readKeyBoard(20, false);
if (sdf.parse(work_end).after(sdf.parse(AJSvc.work_start))) {
applyJobs.get(i).setWork_end(work_end);
String filename="src\\campusjobplatform\\files\\applyjobs.txt";
TSUtility.mySerializable(applyJobs,filename);
break;
}else {
System.out.println("您输入的工作结束时间早于工作开始时间！请重新输入！");
}
}
Date d1 = sdf.parse(applyJobs.get(i).work_start);
Date d2 = sdf.parse(work_end);
if (d1.getTime() + (applyJobs.get(i).job_time * 60 * 60 * 1000) < d2.getTime()) {
System.out.println("您的工作已逾期，信用等级-1");
user.setCredit_rating(user.getCredit_rating() - 1);
String filename="src\\campusjobplatform\\files\\overduejobs.txt";
TSUtility.mySerializable(overdueJobs,filename);
String filename2="src\\campusjobplatform\\files\\journal.txt";
String s="用户"+user.getUserId()+"已结束工作(逾期)："+jobId;
TSUtility.writeJournal(filename2,s);
for (Job job:jobs){
if (AJSvc.JID==job.getJID()){
overdueJobs.add(job);
}
}
}else {
if (user.getCredit_rating()<5){
if (user.getTimes()<3){
user.setTimes(user.getTimes()+1);
System.out.println("再完成"+(3-user.getTimes())+"次工作后信用等级恢复到"+(user.getCredit_rating()+1));
}else {
user.setTimes(0);
user.setCredit_rating(user.getCredit_rating() + 1);
System.out.println("信用等级已恢复到"+user.getCredit_rating());
}
}
String filename2="src\\campusjobplatform\\files\\journal.txt";
String s="用户"+user.getUserId()+"已按时结束工作："+jobId;
TSUtility.writeJournal(filename2,s);
}
flag=false;
}
}
if (AJSvc==null){
System.out.println("未找到正在完成的工作（id："+jobId+"）");
System.out.println("请重新输入！");
continue;
}
for (int i = 0; i < jobs.size(); i++) {
Job j = jobs.get(i);
if (jobId == j.getJID()) {
salary = j.getSalary() - getDeduct_salary(AJSvc, j.getDeduct_salary());
}
}
}
if (salary>=0){
user.setBalance(user.getBalance()+salary);
}else if (-salary<= user.getBalance()){
user.setBalance(user.getBalance()+salary);
}else {
user.setBalance(0);
}
}
}
3559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
