本平台根据角色定位不同有不同的模块，首先系统有一个登录注册模块，属于兼职人员的模块有个人信息管理和兼职申请；属于管理员的模块有基本信息维护、兼职信息投放和系统管理。
功能结构图：
项目功能如下：
（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流直接存在文件，可也直接在文件里读的数据）
源代码如下：
源代码如下：
package cptp.dao;
import cptp.domain.ApplyJob;
import java.io.*;
import java.util.ArrayList;
public class JobDate {
private static File jobFile=new File("E:\\CPTP\\job\\jobList.txt");
private static File applyList=new File("E:\\CPTP\\apply\\applyList.txt");
public static <T> ArrayList<T> readJob() throws IOException, ClassNotFoundException {
if (jobFile == null || jobFile.length() == 0 || !jobFile.exists()) {
return new ArrayList<T>();
}else {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(jobFile));
Object obj = ois.readObject();
ArrayList<T> jobList= (ArrayList<T>) obj;
ois.close();
return jobList;
}
}
public static <T> void writeJob(ArrayList<T> jobList) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(jobFile));
oos.writeObject(jobList);
oos.close();
}
public static ArrayList<ApplyJob> readApplyJobList() throws IOException, ClassNotFoundException {
if (applyList == null || applyList.length() == 0 || !applyList.exists()) {
return new ArrayList<ApplyJob>();
}else {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(applyList));
Object obj = ois.readObject();
ArrayList<ApplyJob> jobList= (ArrayList<ApplyJob>) obj;
ois.close();
return jobList;
}
}
public static void writeApplyJob(ArrayList<ApplyJob> applyJobList) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(applyList));
oos.writeObject(applyJobList);
oos.close();
}
}
package cptp.dao;
import cptp.domain.User;
import java.io.*;
import java.util.HashMap;
import java.util.Properties;
public class RWAccount {
private static File accountRoot = new File("E:\\CPTP\\account");
//读取用户对象,没有则返回null
public static User readUser(String uid) throws IOException, ClassNotFoundException {
User user;
File[] files = accountRoot.listFiles();
for (File file : files) {
String fileName = file.getName();
if (fileName.equals(uid + ".txt")) {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Object obj = ois.readObject();
user = (User) obj;
ois.close();
return user;
}
}
return null;
}
//写数据
public static boolean writeUser(String uid, User user) throws IOException {
File file = new File(accountRoot, uid + ".txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(user);
oos.close();
return true;
}
public static boolean isExist(String uid) {
File[] files = accountRoot.listFiles();
for (File file : files) {
String fileName = file.getName();
if (fileName.equals(uid + ".txt")) {
return true;
}
}
return false;
}
public static Properties nameList() throws IOException {
File file = new File("E:\\CPTP\\nameList.txt");
FileReader fileReader = new FileReader(file);
Properties properties = new Properties();
properties.load(fileReader);
fileReader.close();
// System.out.println(properties);
return properties;
}
public static boolean deleteUser(String uid) {
File file = new File(accountRoot, uid+".txt");
return file.delete();
}
public static void addUserInNameList(String uid, String name) throws IOException {
File file = new File("E:\\CPTP\\nameList.txt");
Properties properties = nameList();
FileWriter fileWriter = new FileWriter(file);
properties.setProperty(uid, name);
properties.store(fileWriter, null);
fileWriter.close();
}
public static HashMap<String,User> readAllUser() throws IOException, ClassNotFoundException {
User user;
File[] files = accountRoot.listFiles();
HashMap<String,User> hashMap=new HashMap<>();
for (File file : files) {
String fileName = file.getName();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Object obj = ois.readObject();
user = (User) obj;
ois.close();
hashMap.put(fileName,user);
}
return hashMap;
}
}
package cptp.domain;
//申请的有哪些人
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ApplyJob implements Serializable {
//序列化唯一标识
private static final long serialVersionUID = 1L;
private String uid; //用户编号
private String jid; //营业执照编号
private Date work_start; //开始工作时间
private Date work_end; //结束工作时间、
private String state="正在进行";//兼职状态
private String name; //申请兼职的学生姓名
private String jobName; //申请兼职的岗位名称
private String JTID;
public ApplyJob() {
}
public ApplyJob(String uid, String jid, Date work_start, Date work_end) {
this.uid = uid;
this.jid = jid;
this.work_start = work_start;
this.work_end = work_end;
}
public String getUid() {
return uid;
}
public void setUid(String uid) {
this.uid = uid;
}
public String getJid() {
return jid;
}
public void setJid(String jid) {
this.jid = jid;
}
public Date getWork_start() {
return work_start;
}
public void setWork_start(Date work_start) {
this.work_start = work_start;
}
public Date getWork_end() {
return work_end;
}
public void setWork_end(Date work_end) {
this.work_end = work_end;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJTID() {
return JTID;
}
public void setJTID(String JTID) {
this.JTID = JTID;
}
@Override
public String toString() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年M月dd日");
String data1 = sdf.format(work_start);
String data2 = sdf.format(work_end);
return "ApplyJob{" +
"接此兼职的用户学号='" + uid + '\'' +
", 申请此兼职的用户姓名='" + name + '\'' +
", 该兼职的公司营业编号='" + jid + '\'' +
", 该兼职的兼职类型编号='" + JTID + '\'' +
", 该兼职的岗位名称='" + jobName + '\'' +
", 开始时间=" + data1 +
", 结束时间=" + data2 +
", 兼职状态='" + state + '\'' +
'}';
}
}
package cptp.domain;
import java.io.Serializable;
public class Job implements Serializable {
private static final long serialVersionUID = 40L;
private String JID;//营业执照编号
private String company_name;//公司名字
private String job_name;//岗位名称
private int job_level;//兼职等级
private String job_content;//工作内容
private int job_demand;//需求人数
private String job_time;//工作时间
private JobType jobType=new JobType();//兼职类型
public Job() {
}
public Job(String JID, String company_name, String job_name, int job_level, String job_content, int job_demand, String job_time, JobType jobType) {
this.JID = JID;
this.company_name = company_name;
this.job_name = job_name;
this.job_level = job_level;
this.job_content = job_content;
this.job_demand = job_demand;
this.job_time = job_time;
this.jobType = jobType;
}
public String getJID() {
return JID;
}
public void setJID(String JID) {
this.JID = JID;
}
public String getCompany_name() {
return company_name;
}
public void setCompany_name(String company_name) {
this.company_name = company_name;
}
public String getJob_name() {
return job_name;
}
public void setJob_name(String job_name) {
this.job_name = job_name;
}
public int getJob_level() {
return job_level;
}
public void setJob_level(int job_level) {
this.job_level = job_level;
}
public String getJob_content() {
return job_content;
}
public void setJob_content(String job_content) {
this.job_content = job_content;
}
public int getJob_demand() {
return job_demand;
}
public void setJob_demand(int job_demand) {
this.job_demand = job_demand;
}
public String getJob_time() {
return job_time;
}
public void setJob_time(String job_time) {
this.job_time = job_time;
}
public JobType getJobType() {
return jobType;
}
public void setJobType(JobType jobType) {
this.jobType = jobType;
}
@Override
public String toString() {
return "营业执照编号='" + JID + '\'' +
", 公司名称='" + company_name + '\'' +
", 职业名称='" + job_name + '\'' +
", 信用等级要求>=" + job_level +
", 工作内容='" + job_content + '\'' +
", 招聘人数=" + job_demand +
", 工作时间='" + job_time + '\'' +
", " + jobType ;
}
}
package cptp.domain;
import java.io.Serializable;
public class JobType implements Serializable {
private static final long serialVersionUID = 39L;
private String JTID;//兼职类型编号
private double salary;//薪水
private double deduct_salary;//逾期费用扣除比例
private String jobType_name;//兼职类型名称
public String getJTID() {
return JTID;
}
public void setJTID(String JTID) {
this.JTID = JTID;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public double getDeduct_salary() {
return deduct_salary;
}
public void setDeduct_salary(double deduct_salary) {
this.deduct_salary = deduct_salary;
}
public String getJobType_name() {
return jobType_name;
}
public void setJobType_name(String jobType_name) {
this.jobType_name = jobType_name;
}
@Override
public String toString() {
return "兼职类型编号='" + JTID + '\'' +
", 兼职类型名称='" + jobType_name + '\''+
", 薪水=" + salary +
", 逾期费用扣除比例=" + deduct_salary*100+"%" ;
}
}
package cptp.domain;
import java.io.Serializable;
import java.util.Date;
//注意：注册日期用的时候再看情况要不要转为字符串
public class User implements Serializable {
private static final long serialVersionUID = 42L;
private String UID;//用户编号(学号/教师编号)
private String passWord;//密码
private String username;//姓名
private int age = 0;//年龄
private String sex = "未知";//性别
private String phone = "未知";//电话
private String department = "未知";//所属院系
private Date regDate=null;//注册日期
private int increase=0;//用于判断是否能提高信用等级的
private UserAccount userAccount; //普通用户账户
public User(String UID, String passWord, String username) {
this.UID = UID;
this.passWord = passWord;
this.username = username;
regDate=new Date();
userAccount=new UserAccount();
userAccount.setACID(UID);
}
public String getUID() {
return UID;
}
public void setUID(String UID) {
this.UID = UID;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public Date getRegDate() {
return regDate;
}
public void setRegDate(Date regDate) {
this.regDate = regDate;
}
public int getIncrease() {
return increase;
}
public void setIncrease(int increase) {
this.increase = increase;
}
public UserAccount getUserAccount() {
return userAccount;
}
public void setUserAccount(UserAccount userAccount) {
this.userAccount = userAccount;
}
@Override
public String toString() {
return "User{" +
"UID='" + UID + '\'' +
", passWord='" + passWord + '\'' +
", username='" + username + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", phone='" + phone + '\'' +
", department='" + department + '\'' +
", regDate=" + regDate +
", increase=" + increase +
", userAccount=" + userAccount +
'}';
}
}
package cptp.domain;
import java.io.Serializable;
public class UserAccount implements Serializable {
private static final long serialVersionUID = 1L;
private String ACID;//账户编号
private int credit_rating=5;//信用等级
private double balance;//余额
public UserAccount() {
}
public UserAccount(String ACID, int credit_rating, double balance) {
this.ACID = ACID;
this.credit_rating = credit_rating;
this.balance = balance;
}
public String getACID() {
return ACID;
}
public void setACID(String ACID) {
this.ACID = ACID;
}
public int getCredit_rating() {
return credit_rating;
}
public void setCredit_rating(int credit_rating) {
this.credit_rating = credit_rating;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
@Override
public String toString() {
return "UserAccount{" +
"ACID='" + ACID + '\'' +
", credit_rating=" + credit_rating +
", balance=" + balance +
'}';
}
}
package cptp.service;
import cptp.dao.JobDate;
import cptp.dao.RWAccount;
import cptp.domain.ApplyJob;
import cptp.domain.Job;
import cptp.domain.User;
import cptp.utility.TSUtility;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
public class ApplyJobService {
public void getJobList() {
System.out.println("下面是所有职位信息：");
ArrayList<Job> jobList=null;
try {
jobList= JobDate.readJob();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println("--------------------------------------------------------------");
for (Job job:jobList) {
System.out.println(job);
}
System.out.println("--------------------------------------------------------------");
}
public void getApplicableOccupation(String uid) {
System.out.println("下面是您当前信用等级可申请的职位列表：");
User user = new UserService().readUser(uid);
ArrayList<Job> jobList=null;
try {
jobList=JobDate.readJob();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println("---------------------------------------------");
for (Job job:jobList) {
if (job.getJob_level()<=user.getUserAccount().getCredit_rating()&&job.getJob_demand()>0){
System.out.println(job);
}
}
System.out.println("---------------------------------------------");
}
public void applyOccupation(String uid) throws IOException, ClassNotFoundException, ParseException {
User user = new UserService().readUser(uid);
ArrayList<Job> jobList=JobDate.readJob();
ArrayList<ApplyJob> applyJobList=JobDate.readApplyJobList();
System.out.println("请输入你想要申请职业的公司营业执照编号(输入-1退出)：");
String JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
System.out.println("请输入你想要申请职业的兼职类型编号：");
String JTID=TSUtility.readKeyBoard(4, false);
Job job=null;
do{
for (Job job1:jobList){
if(job1.getJID().equals(JID)&&job1.getJobType().getJTID().equals(JTID)){
job=job1;
break;
}
}
if (job==null){
System.out.println("未查询到该职业！请重新输入：");
System.out.println("请输入你想要申请职业的公司营业执照编号(输入-1退出)：");
JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
System.out.println("请输入你想要申请职业的兼职类型编号：");
JTID=TSUtility.readKeyBoard(4, false);
}
}while(job==null);
if(job.getJob_level()>user.getUserAccount().getCredit_rating()){
System.out.println("抱歉！您的信用等级不够！");
System.out.println("你还需要按时完成"+(3-user.getIncrease())+"次任务,信用会升至"+
(user.getUserAccount().getCredit_rating()+1)+"级");
}else if (job.getJob_demand()<=0) {
System.out.println("抱歉，您申请的职业已经被抢完了！");
}else{
for (ApplyJob applyJob:applyJobList) {
if (applyJob.getUid().equals(uid)&&applyJob.getState().equals("正在进行")){
System.out.println("您已经有一个兼职正在进行中，得等完成那份兼职之后再尝试申请新的兼职！");
System.out.println("程序将自动返回上一级菜单！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
}
String[] str=job.getJob_time().split("到");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date1 = sdf.parse(str[0]);
Date date2 = sdf.parse(str[1]);
ApplyJob applyJob=new ApplyJob();
applyJob.setWork_start(date1);
applyJob.setWork_end(date2);
applyJob.setJid(job.getJID());
applyJob.setJTID(job.getJobType().getJTID());
applyJob.setUid(uid);
applyJob.setName(user.getUsername());
applyJob.setJobName(job.getJob_name());
job.setJob_demand(job.getJob_demand()-1);
applyJobList.add(applyJob);
JobDate.writeApplyJob(applyJobList);
JobDate.writeJob(jobList);
System.out.println("申请成功");
}
System.out.println("程序将自动返回上一级菜单！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void endWork(String uid) throws IOException, ClassNotFoundException, ParseException {
Job job=null;
ArrayList<ApplyJob> applyJobs = JobDate.readApplyJobList();
User user = RWAccount.readUser(uid);
System.out.println("下面是您正在进行的工作");
boolean find=false;
System.out.println("-----------------------------------------");
for (ApplyJob a :applyJobs) {
if(a.getUid().equals(uid)&&a.getState().equals("正在进行")){
System.out.println(a);
find=true;
break;
}
}
System.out.println("-----------------------------------------");
if(!find){
System.out.println("您没有正在进行的工作！程序将自动返回上一级菜单！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
System.out.println("请输入你想要结束的工作的公司营业编号(输入-1退出)：");
String JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
boolean noFind=true;
System.out.println("请输入你想要结束工作的兼职类型编号");
String JTID=TSUtility.readKeyBoard(4, false);
do{
for (ApplyJob a :applyJobs) {
if(a.getUid().equals(uid)&&a.getJid().equals(JID)
&&a.getState().equals("正在进行")&&a.getJTID().equals(JTID)){
//如果申请列表中，找到了营业编号一样的，用户编号一样的，且那个职业状态是正在进行的
noFind=false;
System.out.println("请手动输入你实际完成的时间(格式:yyyy-MM-dd):");
Date date=TSUtility.readEndWorkDate(a.getWork_start());
ArrayList<Job> jobList = JobDate.readJob();
for (Job job1:jobList) {
if(job1.getJID().equals(JID)){
job=job1;
break;
}
}
if(date.getTime()>a.getWork_end().getTime()){//如果逾期了
long day=(a.getWork_end().getTime()-date.getTime())/1000/60/60/24;
System.out.println("您已经逾期了"+Math.abs(day)+"天");
int credit_rating = user.getUserAccount().getCredit_rating()-1;
user.getUserAccount().setCredit_rating(credit_rating);
System.out.println("您的信誉等级下降1级！下降后的信誉等级为："+credit_rating+"级");
user.getUserAccount().setBalance(user.getUserAccount().getBalance()+
job.getJobType().getSalary()-job.getJobType().getSalary()*job.getJobType().getDeduct_salary()*Math.abs(day));
if(user.getUserAccount().getBalance()<0){
user.getUserAccount().setBalance(0);
System.out.println("您的账户现在余额为0！");
} else {
System.out.println("您现在的余额为："+user.getUserAccount().getBalance());
}
a.setState("逾期完成");
}
else {
System.out.println("恭喜你按时完成任务,下次再接再厉！");
user.setIncrease(user.getIncrease()+1);
int increase = user.getIncrease();
int credit_rating = user.getUserAccount().getCredit_rating();
if (increase==3 && credit_rating<5){
user.getUserAccount().setCredit_rating(credit_rating+1);
user.setIncrease(0);
System.out.println("您的信用等级得到了提升，现在您的信用等级为："+user.getUserAccount().getCredit_rating()+"级");
}else if (increase==3 && credit_rating==5){
System.out.println("您超级守信!!");
}else if(credit_rating<5){
System.out.println("您还需要按时完成"+(3-user.getIncrease())+"次任务后信用等级将会提升!");
}
user.getUserAccount().setBalance(user.getUserAccount().getBalance()+job.getJobType().getSalary());
System.out.println("你现在的账户剩下的金额为："+user.getUserAccount().getBalance());
a.setState("已完成");
}
// a.setState("已完成");
}
}
if(noFind){
System.out.println("没有找到你想要结束的工作！");
System.out.println("请重新输入你想要结束的工作的公司营业编号(输入-1退出)：");
JID = TSUtility.readKeyBoard(18, false);
System.out.println("请输入你想要结束工作的兼职类型编号");
JTID=TSUtility.readKeyBoard(4, false);
}
}while(noFind);
//持久化
RWAccount.writeUser(uid,user);
JobDate.writeApplyJob(applyJobs);
System.out.println("你已成功完成一份职业！！程序将自动返回上一级菜单！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void queryWorking(String uid) throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJobs = JobDate.readApplyJobList();
System.out.println("下面是您正在进行的工作：");
System.out.println("---------------------------------------------");
for (ApplyJob a :applyJobs) {
if (a.getUid().equals(uid)
&&a.getState().equals("正在进行")){
System.out.println(a);
}
}
System.out.println("---------------------------------------------");
System.out.println("查询完毕！程序将自动返回上一级菜单！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void queryCompleted(String uid) throws IOException, ClassNotFoundException {
ArrayList<ApplyJob> applyJobs = JobDate.readApplyJobList();
System.out.println("下面是您已经完成的工作：");
System.out.println("---------------------------------------------");
for (ApplyJob a :applyJobs) {
if (a.getUid().equals(uid)&&
(a.getState().equals("已完成")||a.getState().equals("逾期完成"))){
System.out.println(a);
}
}
System.out.println("---------------------------------------------");
System.out.println("查询完毕！程序将自动返回上一级菜单！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException, ClassNotFoundException, ParseException {
// new ApplyJobService().getApplicableOccupation("S1001");
new ApplyJobService().getJobList();
new ApplyJobService().applyOccupation("S1001");
// new ApplyJobService().endWork("S1001");
// new ApplyJobService().queryCompleted("S1001");
}
}
package cptp.service;
import cptp.domain.Job;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Properties;
public class JobService {
File jobRoot=new File("E:\\CPTP\\job");
public Properties load(File file) throws IOException {
Properties prop = new Properties();
FileReader fr = new FileReader(file);
prop.load(fr);
fr.close();
return prop;
}
public ArrayList<Job> getCompanyList() throws IOException {
// ArrayList<Job> list=new ArrayList<>();
// File[] files = jobRoot.listFiles();
// for (File file:files){
// Properties properties = load(file);
// Job job=new Job();
// job.setJID(properties.getProperty("JID"));
// job.setCompany_name(properties.getProperty("company_name"));
// job.setJob_name(properties.getProperty("job_name"));
// job.setJobType_name(properties.getProperty("jobType_name"));
// job.setJob_level(Integer.parseInt(properties.getProperty("job_level")));
// job.setSalary(Integer.parseInt(properties.getProperty("salary")));
// job.setDeduct_salary(Double.parseDouble(properties.getProperty("deduct_salary")));
// job.setJob_content(properties.getProperty("job_content"));
// job.setJob_demand(Integer.parseInt(properties.getProperty("job_demand")));
// job.setJob_time(properties.getProperty("job_time"));
// list.add(job);
// }
// return list;
return null;
}
public static void main(String[] args) {
}
}
package cptp.service;
import cptp.dao.JobDate;
import cptp.dao.RWAccount;
import cptp.domain.Job;
import cptp.domain.JobType;
import cptp.domain.User;
import cptp.domain.UserAccount;
import cptp.utility.TSUtility;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
public class ManagementService {
UserService userService=new UserService();
//兼职人员的兼职等设置
public void setCredit_rating() throws IOException, ClassNotFoundException {
HashMap<String, User> hashMap = RWAccount.readAllUser();
System.out.println("下面是所有用户信息：");
System.out.println("----------------------------------------------");
for(String key:hashMap.keySet()){
if (key.startsWith("S"))
System.out.println("学号为："+key.substring(0,key.length()-4)+" 姓名为："+hashMap.get(key).getUsername()
+" 当前的信用等级为"+hashMap.get(key).getUserAccount().getCredit_rating()+"级");
}
System.out.println("----------------------------------------------");
System.out.println("请输入你想要调整信用等级的用户的学号(输入-1返回):");
String uid=TSUtility.readKeyBoard(10,false);
if(uid.equals("-1")){
return;
}
User user=null;
while(!uid.startsWith("S")||(user=userService.readUser(uid))==null){
System.out.println("没有找到该学生，请重新输入！(输入-1返回)");
uid=TSUtility.readKeyBoard(10,false);
if(uid.equals("-1")){
return;
}
}
UserAccount userAccount = user.getUserAccount();
int credit_rating = userAccount.getCredit_rating();
System.out.println("当前用户的信用等级是"+credit_rating);
if(credit_rating==0){
System.out.println("当前用户的信用等级过低，您无法修改调整此用户的信用等级！");
} else {
System.out.println("请输入你想要将其调整为几级：");
String i= String.valueOf(TSUtility.readFive());
userAccount.setCredit_rating(Integer.parseInt(i));
userService.write(uid,user);
System.out.println("您已成功将此用户的信用等级调整为"+i+"级");
}
System.out.println("程序将自动返回！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void setJob_level() {
ArrayList<Job> jobList=null;
try {
jobList = JobDate.readJob();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println();
System.out.println("所有职业列表展示：");
System.out.println("-------------------------------------------");
System.out.println("营业编号\t\t\t\t公司名称\t职业名称\t兼职类型编号\t兼职等级");
System.out.println("-------------------------------------------");
for (Job job:jobList){
System.out.println(job.getJID()+"\t"+job.getCompany_name()+"\t"+job.getJob_name()+"\t"+job.getJobType().getJTID()+"\t\t"+job.getJob_level());
}
System.out.println("-------------------------------------------");
System.out.println("请输入你想要修改的信用等级的营业执照编号(输入-1退出)：");
String JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
System.out.println("请输入你想要修改信用等级的兼职的兼职类型编号：");
String JTID=TSUtility.readKeyBoard(4, false);
Job job=null;
do{
for (Job job1:jobList){
if(job1.getJID().equals(JID)&&job1.getJobType().getJTID().equals(JTID)){//如果你输入的公司营业编号和职业的类型编号一样就拿到那个职业，不然返回null
job=job1;
break;
}
}
if (job==null){
System.out.println("未查询到该职业！请重新输入：");
System.out.println("请输入你想要修改的信用等级的营业执照编号(输入-1返回)：");
JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
System.out.println("请输入你想要修改信用等级的兼职的兼职类型编号：");
JTID=TSUtility.readKeyBoard(4, false);
}
}while(job==null);
System.out.println("请输入你想将其兼职等级修改为多少级：");
String i= String.valueOf(TSUtility.readFive());
job.setJob_level(Integer.parseInt(i));
try {
JobDate.writeJob(jobList);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("该公司的兼职等级已经成功修改为"+i+"级！");
System.out.println("程序将自动返回！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void setJobType() {
ArrayList<Job> jobList=null;
try {
jobList = JobDate.readJob();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println();
System.out.println("所有职业和其兼职类型展示：");
System.out.println("-----------------------------------------------------------------------------");
System.out.println("营业编号\t\t\t\t公司名称\t职业名称\t兼职类型编号\t兼职类型名\t薪水 \t逾期扣费比例");
System.out.println("-----------------------------------------------------------------------------");
for (Job job:jobList){
System.out.println(job.getJID()+"\t"+job.getCompany_name()+"\t"+job.getJob_name()+"\t"+
job.getJobType().getJTID()+"\t\t"+job.getJobType().getJobType_name()+" " +
"\t\t"+job.getJobType().getSalary()+"\t"+job.getJobType().getDeduct_salary()*100+"%");
}
System.out.println("-----------------------------------------------------------------------------");
System.out.println("请输入你想要修改的职业类型的营业执照编号(输入-1返回)：");
String JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
System.out.println("请输入你想要修改兼职的兼职类型编号：");
String JTID=TSUtility.readKeyBoard(4, false);
Job job=null;
do{
for (Job job1:jobList){
if(job1.getJID().equals(JID)&&job1.getJobType().getJTID().equals(JTID)){
job=job1;
break;
}
}
if (job==null){
System.out.println("未查询到该职业！请重新输入：");
System.out.println("请输入你想要修改的职业类型的营业执照编号(输入-1返回)：");
JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
return;
}
System.out.println("请输入你想要修改兼职的兼职类型编号：");
JTID=TSUtility.readKeyBoard(4, false);
}
}while(job==null);
JobType jobType = job.getJobType();
System.out.println("请输入兼职类型名(按下Enter代表不修改),"+"\t"+"现在的兼职类型名是："+jobType.getJobType_name());
String jobType_name=TSUtility.readKeyBoard(4, true);
jobType.setJobType_name(jobType_name.equals("")?jobType.getJobType_name():jobType_name);
System.out.println("请输入该职业的薪水(按下Enter代表不修改),"+"\t"+"现在该职业的薪水是："+jobType.getSalary());
jobType.setSalary(TSUtility.readDouble(true,jobType.getSalary()));
System.out.println("请输入该职业的逾期扣费比例(按下Enter代表不修改),"+"\t"+"现在逾期扣费比例是："+jobType.getDeduct_salary()*100+"%");
System.out.println("注意：比如要输入25%，你只需要输入25即可");
String s=TSUtility.readKeyBoard(2,true);
if(s.equals("")){
jobType.setDeduct_salary(jobType.getDeduct_salary());
} else {
jobType.setDeduct_salary(Integer.parseInt(s)/100.0);
}
try {
JobDate.writeJob(jobList);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("修改成功，程序将自动返回！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
// new AssignmentDeliveryView().enterDeliveryView();
// new ManagementService().setCredit_rating();
// new ManagementService().setJob_level();
new ManagementService().setJobType();
}
}
package cptp.service;
import cptp.dao.JobDate;
import cptp.dao.RWAccount;
import cptp.domain.ApplyJob;
import cptp.domain.Job;
import cptp.domain.User;
import cptp.domain.UserAccount;
import cptp.utility.PrintUtility;
import cptp.utility.TSUtility;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
public class SystemManagementService {
public void manUserInfo() throws IOException, ClassNotFoundException {
do {
PrintUtility.printWelcome("欢迎来到管理用户信息界面！");
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(退出)");
System.out.println("请输入你需要进行的操作：");
char c = TSUtility.readSeven();
label:
switch (c) {
case '1':
//修改用户基本信息
String uid;
User user;
do {
System.out.println("请输入你想要修改的用户uid(输入-1返回上级菜单)：");
uid = TSUtility.readKeyBoard(10, false);
try {
user = RWAccount.readUser(uid);
if (uid.equals("-1")) {
break label;
} else if (user == null) {
System.out.println("您输入的账号未注册，请检查是否输入有误!");
} else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
} while (true);
System.out.println("当前用户的年龄是”" + user.getAge() + "“(按下Enter代表不修改):");
int age = TSUtility.readAge(user.getAge());
user.setAge(age);
System.out.println("当前用户的性别是”" + user.getSex() + "“(按下Enter代表不修改)：");
String sex = TSUtility.readSex(user.getSex());
user.setSex(sex);
System.out.println("当前用户的手机号是”" + user.getPhone() + "“(按下Enter代表不修改)：");
String phone = TSUtility.readPhone(user.getPhone());
user.setPhone(phone);
System.out.println("当前用户的所属院系是”" + user.getDepartment() + "“(按下Enter代表不修改)：");
String department = TSUtility.readString(10, user.getDepartment());
user.setDepartment(department);
new UserService().write(uid, user);
System.out.println("个人信息修改成功！程序将自动返回！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
break;
case '2':
//修改用户账户信息
do {
System.out.println("请输入你想要修改账户号(输入-1返回上级菜单)：");
System.out.println("注意：为了方便记忆，账户号和学生的学号一致！");
uid = TSUtility.readKeyBoard(10, false);
try {
user = RWAccount.readUser(uid);
if (uid.equals("-1")) {
break label;
} else if (user == null) {
System.out.println("您输入的账户号不存在，请检查是否输入有误!");
} else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
} while (true);
UserAccount userAccount = user.getUserAccount();
System.out.println("下面是该用户的账户信息：");
System.out.println("----------------------------------------");
System.out.println("账户编号\t账户信用等级\t账户余额");
System.out.println(userAccount.getACID() + "\t" + userAccount.getCredit_rating() + "\t\t\t" + userAccount.getBalance());
System.out.println("----------------------------------------");
System.out.println("请输入你想要修改的选项(1.修改账户信用等级 2.修改账户余额)");
char c1 = TSUtility.readTwo();
if (c1 == '1') {
System.out.println("请输入你想将账户信用等级修改为多少？");
char c2 = TSUtility.readFive();
userAccount.setCredit_rating(Integer.parseInt(String.valueOf(c2)));
} else if (c1 == '2') {
System.out.println("请输入你想将账户的余额修改为多少：");
boolean flag = true;
do {
try {
int i = Integer.parseInt(TSUtility.readKeyBoard(7, false));
flag = false;
userAccount.setBalance(i);
} catch (RuntimeException r) {
System.out.println("请输入数值！！");
}
} while (flag);
}
new UserService().write(uid, user);
System.out.println("个人信息修改成功！程序将自动返回！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
break;
case '3':
//删除用户
do {
System.out.println("请输入你想删除的用户uid(输入-1可以返回上一级菜单)：");
uid = TSUtility.readKeyBoard(10, false);
if(uid.startsWith("T")){
System.out.println("在此界面您无法操作老师的账号");
continue ;
}
try {
user = RWAccount.readUser(uid);
if (uid.equals("-1")) {
break label;
} else if (user == null) {
System.out.println("您输入的用户不存在，请检查是否输入有误!");
} else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
} while (true);
System.out.println("请确认是否删除此用户(输入Y或N)");
if (TSUtility.readConfirmSelection() == 'Y') {
if(RWAccount.deleteUser(uid)){
System.out.println("删除成功！");
}else {
System.out.println("删除失败！");
}
} else {
System.out.println("删除失败！");
}
break;
case '4':
//删除账户
do {
System.out.println("注意此处的删除账户是把账户初始化(若你想真正地删除账户，请用删除用户选项！)");
System.out.println("请输入你想删除的账户(输入-1可以返回上一级菜单)：");
uid = TSUtility.readKeyBoard(10, false);
if(uid.startsWith("T")){
System.out.println("在此界面您无法操作老师的账号");
continue ;
}
try {
user = RWAccount.readUser(uid);
if (uid.equals("-1")) {
break label;
} else if (user == null) {
System.out.println("您输入的账户不存在，请检查是否输入有误!");
} else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
} while (true);
System.out.println("请确认是否删除此账户！(输入Y或N)");
if (TSUtility.readConfirmSelection() == 'Y') {
user.setUserAccount(new UserAccount(user.getUserAccount().getACID(),5,0));
new UserService().write(uid, user);
} else {
System.out.println("删除失败！");
}
break;
case '5':
//添加用户
System.out.println("请输入学生uid，若本系统中没有该生的uid可以把该生添加到系统(输入-1返回上级菜单)(这个功能也可以用来创建管理员账号)：");
uid = TSUtility.readKeyBoard(10, false);
try {
user = RWAccount.readUser(uid);
if (uid.equals("-1")) {
break;
} else if (user == null &&
!(new UserService().uidInList(uid))) {
System.out.println("您输入的账户不存在，您是否选择要添加该生到本校学生系统!(输入Y或N)");
if(TSUtility.readConfirmSelection()=='Y'){
do{
System.out.println("请输入你该生/管理员的学号/教师编号：");
uid = TSUtility.readKeyBoard(10, false);
if(!uid.startsWith("T")&&!uid.startsWith("S")){
System.out.println("输入格式错误，学生的学号以S开头，管理员的教师编号用T开头");
System.out.println("请重新输入：");
}else {
break;
}
}while(true);
System.out.println("请输入该生/管理员的姓名：");
String name = TSUtility.readKeyBoard(5, false);
RWAccount.addUserInNameList(uid,name);
System.out.println("您已经成功在本校系统中添加该用户信息！！");
System.out.println("现在可以注册账号了！！");
System.out.println("请输入你的密码:");
String password = TSUtility.readKeyBoard(15, false);
//需要输入两次密码一样
do{
System.out.println("请再次输入密码");
if (password.equals(TSUtility.readKeyBoard(15, false))){
break;
} else {
System.out.println("两次输入的密码不一样！");
}
}while (true);
if(new UserService().createAccount(uid,password,name)){
System.out.println("用户创建成功！！");
}
}
} else if(new UserService().uidInList(uid)&&user==null){
System.out.println("该生已经在本校系统中，请开始你的注册！");
System.out.println("请输入该生的姓名：");
String name = TSUtility.readKeyBoard(5, false);
while(!new UserService().nameOfUid(uid,name)){
System.out.println("您输入的名字与学号不匹配");
System.out.println("请重新输入！");
name = TSUtility.readKeyBoard(5, false);
}
System.out.println("请输入密码:");
String password = TSUtility.readKeyBoard(15, false);
//需要输入两次密码一样
do{
System.out.println("请再次输入密码");
if (password.equals(TSUtility.readKeyBoard(15, false))){
break;
} else {
System.out.println("两次输入的密码不一样！");
}
}while (true);
if(new UserService().createAccount(uid,password,name)){
System.out.println("用户创建成功！");
}
} else if(user!=null){
System.out.println("该账号已经被注册！！！");
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
break;
case '6':
//查看所有用户和其账户信息
HashMap<String, User> hashMap = RWAccount.readAllUser();
System.out.println("下面是所有用户和他账户的信息：");
System.out.println("----------------------------------------------");
for(String key:hashMap.keySet()){
System.out.println("学号为："+key.substring(0,key.length()-4)+" 账号信息为："+hashMap.get(key));
}
System.out.println("----------------------------------------------");
break;
case '7':
//退出
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
} while (true);
}
public void manJobInfo() throws IOException, ClassNotFoundException {
do {
PrintUtility.printWelcome("欢迎来到兼职信息管理界面");
System.out.println("1(修改投放的兼职信息)");
System.out.println("2(删除投放的兼职)");
System.out.println("3(查看所有已投放的兼职)");
System.out.println("4(退出)");
System.out.println("请输入你需要进行的操作：");
char c = TSUtility.readForth();
label:switch (c){
case '1':
//修改投放的兼职信息
System.out.println("下面是所有已投放的兼职：");
System.out.println("---------------------------------------------");
ArrayList<Job> list = JobDate.readJob();
for(Job job:list)
System.out.println(job);
System.out.println("---------------------------------------------");
System.out.println("请输入你想要修改的兼职的职业执照编号(输入-1返回)：");
boolean bool=true;
String JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
break;
}
System.out.println("请输入你想要修改的兼职类型编号：");
String JTID=TSUtility.readKeyBoard(4, false);
Job job=null;
while(bool){
for(Job job1:list){
if(JID.equals(job1.getJID())&&job1.getJobType().getJTID().equals(JTID)){
job=job1;
bool=false;
break;
}
}
if(bool){
System.out.println("没有找到该营业编号的职业，请重新输入(输入-1返回)：");
JID=TSUtility.readKeyBoard(18,false);
if(JID.equals("-1")){
break label;
}
System.out.println("请输入你想要修改兼职的兼职类型编号：");
JTID=TSUtility.readKeyBoard(4, false);
}
}
System.out.println("请按需修改(按回车不修改)：");
System.out.println("请输入公司名称(按下Enter代表不修改),"+"\t"+"现在的公司名称是："+job.getCompany_name());
String company_name =TSUtility.readKeyBoard(10,true);
job.setCompany_name(company_name.equals("")?job.getCompany_name():company_name);
System.out.println("请输入投放职业名称(按下Enter代表不修改),"+"\t"+"现在的职业名称是："+job.getJob_name());
String job_name = TSUtility.readKeyBoard(10, true);
job.setJob_name(job_name.equals("")?job.getJob_name():job_name);
System.out.println("请输入投放职业的信用等级(按下Enter代表不修改),"+"\t"+"现在该职业的信用等级是："+job.getJob_level());
char c1;
if((c1=TSUtility.readFivePlus())=='n'){
job.setJob_level(job.getJob_level());
}else {
job.setJob_level(Integer.parseInt(String.valueOf(c1)));
}
System.out.println("请输入职业工作内容(按下Enter代表不修改),"+"\t"+"现在的工作内容是："+job.getJob_content());
String job_content =TSUtility.readKeyBoard(150,true);
job.setJob_content(job_content.equals("")?job.getJob_content():job_content);
System.out.println("请输入招聘人数(按下Enter代表不修改),"+"\t"+"现在的招聘人数是："+job.getJob_demand());
String job_demand;
do {
try {
job_demand=TSUtility.readKeyBoard(2,true);
if(job_demand.equals("")){
job.setJob_demand(job.getJob_demand());
}else {
int i = Integer.parseInt(job_demand);
job.setJob_demand(i);
}
break;
}catch (RuntimeException r){
System.out.println("请输入数字");
}
}while(true);
System.out.println("请输入工作时间，当前的工作时间是“"+job.getJob_time()+"”(按下Enter代表不修改)：(注意：输入格式为”yyyy-MM-dd到yyyy-MM-dd“)：");
String job_time = TSUtility.readJobTimePro();
job.setJob_time(job_time.equals("")?job.getJob_time():job_time);
System.out.println("请输入职业兼职类型编号(按下Enter代表不修改),"+"\t"+"现在的兼职类型编号是："+job.getJobType().getJTID());
JTID=TSUtility.readKeyBoard(4, true);
job.getJobType().setJTID(JTID.equals("")?job.getJobType().getJTID():JTID);
System.out.println("请输入兼职类型名(按下Enter代表不修改),"+"\t"+"现在的兼职类型名是："+job.getJobType().getJobType_name());
String jobType_name=TSUtility.readKeyBoard(4, true);
job.getJobType().setJobType_name(jobType_name.equals("")?job.getJobType().getJobType_name():jobType_name);
System.out.println("请输入兼职薪水(按下Enter代表不修改),"+"\t"+"现在的兼职薪水是："+job.getJobType().getSalary());
job.getJobType().setSalary(TSUtility.readDouble(true,job.getJobType().getSalary()));
System.out.println("请输入该兼职的逾期扣费比例(按下Enter代表不修改),"+"\t"+"现在逾期扣费比例是："+job.getJobType().getDeduct_salary()*100+"%");
System.out.println("注意：比如要输入25%，你只需要输入25即可");
String s=TSUtility.readKeyBoard(2,true);
if(s.equals("")){
job.getJobType().setDeduct_salary(job.getJobType().getDeduct_salary());
} else {
job.getJobType().setDeduct_salary(Integer.parseInt(s)/100.0);
}
try {
JobDate.writeJob(list);
} catch (IOException e) {
e.printStackTrace();
}
break;
case '2':
//删除投放的兼职
System.out.println("下面是所有已投放的兼职：");
System.out.println("---------------------------------------------");
list = JobDate.readJob();
for(Job job1:list)
System.out.println(job1);
System.out.println("---------------------------------------------");
System.out.println("请输入你想要删除兼职的公司营业执照编号(输入-1返回)：");
bool=true;
JID = TSUtility.readKeyBoard(18, false);
if(JID.equals("-1")){
break;
}
System.out.println("请输入你想要删除兼职的兼职类型编号：");
JTID=TSUtility.readKeyBoard(4, false);
while(bool){
for(Job job1:list){
if(JID.equals(job1.getJID())&&job1.getJobType().getJTID().equals(JTID)){
bool=false;
list.remove(job1);
System.out.println("删除成功！！");
break;
}
}
if(bool){
System.out.println("没有找到该营业编号的职业，请重新输入(输入-1返回)：");
JID=TSUtility.readKeyBoard(18,false);
if(JID.equals("-1")){
break;
}
}
}
try {
JobDate.writeJob(list);
} catch (IOException e) {
e.printStackTrace();
}
break;
case '3':
//查看所有已投放的兼职
System.out.println("下面是所有已投放的兼职：");
System.out.println("---------------------------------------------");
list = JobDate.readJob();
for(Job job1:list)
System.out.println(job1);
System.out.println("---------------------------------------------");
break;
case '4':
//退出
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
}while(true);
}
public void manManagerInfo() throws IOException, ClassNotFoundException {
do {
PrintUtility.printWelcome("欢迎来到管理员信息管理界面");
System.out.println("1(查看所有管理员信息)");
System.out.println("2(修改管理员信息)");
System.out.println("3(修改管理员密码)");
System.out.println("4(删除管理员信息)");
System.out.println("5(退出)");
System.out.println("请输入你需要进行的操作：");
char c = TSUtility.readFive();
label:switch (c){
case '1':
//查看所有管理员信息
HashMap<String, User> hashMap = RWAccount.readAllUser();
System.out.println("以下是所有管理员信息：");
System.out.println("------------------------------------------------------------------------");
for(String key:hashMap.keySet()){
if(key.startsWith("T")){
System.out.println(hashMap.get(key));
}
}
System.out.println("------------------------------------------------------------------------");
break;
case '2':
//修改管理员信息
User user=null;
String uid;
do {
System.out.println("请输入您要修改的用户的uid(输入-1返回上级菜单)：");
uid = TSUtility.readKeyBoard(10, false);
if (uid.equals("-1")){
break label;
}
if(!uid.startsWith("T")){
System.out.println("请检查你输入的uid是否为管理员账号！");
continue;
}
try {
user=RWAccount.readUser(uid);
if(user==null){
System.out.println("您输入的账号未注册，请检查是否输入有误!");
}else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}while (true);
do {
System.out.println("请输入你想要修改的信息：");
System.out.println("输入1修改年龄");
System.out.println("输入2修改性别");
System.out.println("输入3修改手机号");
System.out.println("输入4修改所属部门");
char c1 = TSUtility.readFive();
if(c1=='1'){
System.out.println("请输入新年龄：");
user.setAge(TSUtility.readAge(user.getAge()));
break;
} else if(c1=='2'){
System.out.println("请输入新性别：");
user.setSex(TSUtility.readSex(user.getSex()));
break;
} else if(c1=='3'){
System.out.println("请输入新手机号：");
user.setPhone(TSUtility.readPhone(user.getPhone()));
break;
} else if(c1=='4'){
System.out.println("请输入新的部门");
user.setDepartment(TSUtility.readString(10,user.getDepartment()));
break;
} else {
System.out.println("输入错误!");
}
}while(true);
System.out.println("修改成功！！");
new UserService().write(uid,user);
break;
case '3':
//修改管理员密码
do {
System.out.println("请输入您要修改的用户的uid(输入-1返回上级菜单)：");
uid = TSUtility.readKeyBoard(10, false);
if (uid.equals("-1")){
break label;
}
if(!uid.startsWith("T")){
System.out.println("请检查你输入的uid是否为管理员账号！");
continue;
}
try {
user=RWAccount.readUser(uid);
if(user==null){
System.out.println("您输入的账号未注册，请检查是否输入有误!");
}else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}while (true);
System.out.println("请输入新密码：");
String newPassword = TSUtility.readKeyBoard(15, false);
do{
System.out.println("请再次输入密码");
if (newPassword.equals(TSUtility.readKeyBoard(15, false))){
break;
} else {
System.out.println("两次输入的密码不一样！");
}
}while (true);
user.setPassWord(newPassword);
System.out.println("修改成功！！");
new UserService().write(uid,user);
break;
case '4':
//删除管理员信息
do {
System.out.println("请输入您要删除的用户的uid(输入-1返回上级菜单)：");
uid = TSUtility.readKeyBoard(10, false);
if (uid.equals("-1")){
break label;
}
if(!uid.startsWith("T")){
System.out.println("请检查你输入的uid是否为管理员账号！");
continue;
}
try {
user=RWAccount.readUser(uid);
if(user==null){
System.out.println("您输入的账号未注册，请检查是否输入有误!");
}else {
break;
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}while (true);
if(RWAccount.deleteUser(uid))
System.out.println("删除成功！");
break;
case '5':
//退出
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
}while(true);
}
public void manApplyJob() throws IOException, ClassNotFoundException {
do{
PrintUtility.printWelcome("欢迎来到管理已接的兼职管理界面");
System.out.println("1(查看已完成的兼职)");
System.out.println("2(查看正在进行中的兼职)");
System.out.println("3(查看已逾期的兼职)");
System.out.println("4(删除兼职记录)");
System.out.println("5(退出)");
System.out.println("请输入你需要进行的操作：");
char c = TSUtility.readFive();
label:switch (c){
case '1':
//查看已完成的兼职
ArrayList<ApplyJob> applyJobs = JobDate.readApplyJobList();
System.out.println("下面是已经完成的兼职：");
System.out.println("---------------------------");
for (ApplyJob a :applyJobs) {
if (a.getState().equals("已完成")||a.getState().equals("逾期完成")){
System.out.println(a);
}
}
System.out.println("---------------------------");
System.out.println("查询完毕！！");
break;
case '2':
//查看正在进行中的兼职
applyJobs = JobDate.readApplyJobList();
System.out.println("下面是正在进行中的兼职：");
System.out.println("---------------------------");
for (ApplyJob a :applyJobs) {
if (a.getState().equals("正在进行")){
System.out.println(a);
}
}
System.out.println("---------------------------");
System.out.println("查询完毕！！");
break;
case '3':
//查看已逾期的兼职
applyJobs = JobDate.readApplyJobList();
System.out.println("下面是已逾期的兼职：");
System.out.println("---------------------------");
for (ApplyJob a :applyJobs) {
if (a.getState().equals("逾期完成")){
System.out.println(a);
}
}
System.out.println("---------------------------");
System.out.println("查询完毕！！");
break;
case '4':
//删除兼职记录
applyJobs = JobDate.readApplyJobList();
if (applyJobs.size()==0){
System.out.println("当前没有兼职记录!");
break;
}
System.out.println("请输入你想要删除的兼职记录的公司营业执照(输入-1退出)：");
String JID = TSUtility.readKeyBoard(18, false);
if (JID.equals("-1")){
break;
}
System.out.println("请输入你想要删除兼职的兼职类型编号：");
String JTID=TSUtility.readKeyBoard(4, false);
boolean flag=true;
do{
for (ApplyJob a :applyJobs) {
if (a.getJid().equals(JID)&&a.getJTID().equals(JTID)){
applyJobs.remove(a);
flag=false;
break;
}
}
if (flag){
System.out.println("没有找到该职业，请检查是否输入错误！");
System.out.println("请输入你想要删除的兼职记录的公司营业执照：");
JID = TSUtility.readKeyBoard(18, false);
if (JID.equals("-1")){
break label;
}
System.out.println("请输入你想要删除兼职的兼职类型编号：");
JTID=TSUtility.readKeyBoard(4, false);
}
}while(flag);
JobDate.writeApplyJob(applyJobs);
System.out.println("删除成功！");
break;
case '5':
//返回
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
return;
}
}while(true);
}
public static void main(String[] args) {
try {
new SystemManagementService().manApplyJob();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
package cptp.service;
import cptp.dao.RWAccount;
import cptp.domain.User;
import java.io.IOException;
import java.util.Properties;
public class UserService {
public boolean createAccount(String uid,String password,String username){
User user=new User(uid,password,username);
try {
RWAccount.writeUser(uid,user);
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
public User readUser(String uid) {
try {
return RWAccount.readUser(uid);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
public void write(String uid,User user) {
try {
RWAccount.writeUser(uid,user);
} catch (IOException e) {
e.printStackTrace();
}
}
public boolean isRepeat(String uid) {
return RWAccount.isExist(uid);
}
public boolean uidInList(String uid) {
Properties properties=null;
try {
properties=RWAccount.nameList();
} catch (IOException e) {
e.printStackTrace();
}
if (properties.containsKey(uid)){
return true;
}
return false;
}
public boolean nameOfUid(String uid, String name) {
Properties properties=null;
try {
properties=RWAccount.nameList();
} catch (IOException e) {
e.printStackTrace();
}
if(properties.getProperty(uid).equals(name)){
return true;
}
return false;
}
}
package cptp.utility;
public class PrintUtility {
public static void printWelcome(String content){
System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
System.out.println("🔣 🔣");
System.out.println("🔣 "+content+" 🔣");
System.out.println("🔣 🔣");
System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
System.out.println("🐕");
}
public static void printHomePage(){
System.out.println("🐕-----------<请您先登录平台>---------------🐕");
System.out.println("🐕------------1.注册--------------🐕");
System.out.println("🐕------------2.登录--------------🐕");
System.out.println("🐕-----------3.找回密码------------🐕");
System.out.println("🐕-----------4.退出系统------------🐕");
System.out.println("请选择：");
}
public static void printPartTimeMenu(){
System.out.println("🐻1. <个人信息管理> *");
System.out.println("🐘2. <兼职申请> *");
System.out.println("🦊3. <退出系统> *");
System.out.println("请选择：");
}
public static void printPersonalInfoMan(){
System.out.println("1.修改个人信息");
System.out.println("2.修改密码");
System.out.println("3.查询信用等级");
System.out.println("4.查询余额");
System.out.println("5.返回上级菜单");
System.out.println("请选择：");
}
public static void printManagersMenu() {
System.out.println("🐻1. <基本信息维护> *");
System.out.println("🐘2. <兼职信息投放> *");
System.out.println("🐘3. <系统管理> *");
System.out.println("🦊4. <退出系统> *");
System.out.println("请选择：");
}
public static void printPartTimeAppChoice() {
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.返回上级菜单");
System.out.println("请选择：");
}
public static void printBaseInfoMenu() {
System.out.println("1.兼职等级设置");
System.out.println("2.兼职类型设置(包括逾期费用扣除比例调整)");
System.out.println("3.用户信用调整");
System.out.println("4.返回上级菜单");
System.out.println("请选择：");
}
public static void printSysManChoice() {
System.out.println("1(管理用户信息)");
System.out.println("2(管理所有投放的兼职信息)");
System.out.println("3(操作管理员信息)");
System.out.println("4(管理已接的兼职信息)");
System.out.println("5(退出)");
System.out.println("请输入你需要进行的操作：");
}
}
package cptp.utility;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.Scanner;
public class TSUtility {
private static Scanner scanner = new Scanner(System.in);
//读1-4的选项
public static char readForth() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);
c = str.charAt(0);
if (c != '1' && c != '2' &&
c != '3' && c != '4') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
//读1-2的选项，但是返回String
public static char readTwo() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);
c = str.charAt(0);
if (c != '1' && c != '2') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
//只能读1-3的选项
public static char readThree() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);
c = str.charAt(0);
if (c != '1' && c != '2' &&
c != '3') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
//停下来，你按回车才继续执行
public static void readReturn() {
System.out.println("按回车键继续...");
readKeyBoard(100, true);
}
//ok
//从键盘读取年龄
public static int readAge(int defaultValue) {
int age;
for (; ; ) {
String str = readKeyBoard(2, true);
try {
int newAge = Integer.parseInt(str);
age =newAge;
if (age == 0) {
return 0;
} else if (age < 18 || age > 50) {
System.out.println("输入的年龄不符合，要求兼职人员年龄在18-50岁之间。请重新输入：");
} else {
return age;
}
} catch (RuntimeException runtimeException) {
return defaultValue;
}
}
}
public static Double readDouble() {
Double n;
for (; ; ) {
String str = readKeyBoard(6, false);
try {
n = Double.parseDouble(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
public static Double readDouble(boolean bool,double defaultValue) {
Double n;
for (; ; ) {
String str = readKeyBoard(6, bool);
try {
if (str.equals(""))
return defaultValue;
n = Double.parseDouble(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
public static char readConfirmSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
public static String readString(int limit, String defaultValue) {
String str = readKeyBoard(limit, true);
return str.equals("")? defaultValue : str;
}
public static String readKeyBoard(int limit, boolean blankReturn) {
String line = "";
while (scanner.hasNextLine()) {
line = scanner.nextLine();
if (line.length() == 0) {
if (blankReturn) {
return line;
} else {
System.out.println("输入不能为空，请重新输入！");
continue;
}
}
if ( line.length() > limit) {
System.out.print("输入命令长度（不能大于" + limit + "），请重新输入：");
continue;
}
break;
}
return line;
}
public static void loadSpecialEffects() throws InterruptedException {
System.out.println("请稍等：");
for (int i1 = 1; i1 <= 100; i1++) {
System.out.print("加载中：" + i1 + "%");
Thread.sleep(new Random().nextInt(25) + 1);
if (i1 == 100) {
Thread.sleep(50);
}
System.out.print("\r");
}
}
public static char readFive() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);
c = str.charAt(0);
if (c != '1' && c != '2' &&
c != '3'&& c !='4'&& c !='5') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
public static char readFivePlus() {
char c;
for (; ; ) {
String str = readKeyBoard(1, true);
if (str.equals("")){
return 'n';
}
c = str.charAt(0);
if (c != '1' && c != '2' &&
c != '3'&& c !='4'&& c !='5') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
//从键盘兼职人员的性别
public static String readSex(String defaultValue) {
String sex=null;
for (; ; ) {
String str = readKeyBoard(1, true);
sex=str.equals("")? defaultValue : str;
if (sex.equals("男") || sex.equals("女")||sex.equals("未知")) {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return sex;
}
//从键盘读兼职人员的手机号
public static String readPhone(String defaultValue) {
String phoneNum=null;
for (; ; ) {
String str = readKeyBoard(11, true);
phoneNum=str.equals("")? defaultValue : str;
if (phoneNum.equals("未知")){
return phoneNum;
}
if (phoneNum.length()==11) {
break;
} else {
System.out.print("请输入11位的手机号：");
}
}
return phoneNum;
}
public static char readSeven() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);
c = str.charAt(0);
if (c != '1' && c != '2' &&
c != '3'&& c !='4'&& c !='5'&& c!='6'&&c!='7') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
public static int readRecNum() {
while(true){
try{
String s = readKeyBoard(2, false);
int i = Integer.parseInt(s);
if(i<100 && i>0){
return i;
}
}catch (RuntimeException e){
System.out.println("输入错误请重新输入：");
}
}
}
public static String readJobTime() {
//yyyy-MM-dd到yyyy-MM-dd
String time=null;
do{
try {
time=readKeyBoard(23,false);
String[] str=time.split("到");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
int m1= Integer.parseInt(str[0].split("-")[1]);
int m2= Integer.parseInt(str[1].split("-")[1]);
int d1= Integer.parseInt(str[0].split("-")[2]);
int d2= Integer.parseInt(str[1].split("-")[2]);
Date date1 = sdf.parse(str[0]);
Date date2 = sdf.parse(str[1]);
Date now=new Date();
if(date1.getTime()>date2.getTime()){
System.out.println("输入的开始时间应该比结束时间早！");
System.out.println("请重新输入：");
}else if(now.getTime()>date1.getTime()){
System.out.println("开始时间应该比今日时间晚");
System.out.println("请重新输入：");
}else if(m1>12||m2>12||d1>31||d2>31){
System.out.println("输入错误，请重新输入");
}else {
return time;
}
} catch (Exception e) {
System.out.println("输入错误，请重新输入！");
}
}while(true);
}
public static String readJobTimePro() {
//yyyy-MM-dd到yyyy-MM-dd
String time=null;
do{
try {
time=readKeyBoard(23,true);
if (time.equals("")){
return time;
}
String[] str=time.split("到");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
int m1= Integer.parseInt(str[0].split("-")[1]);
int m2= Integer.parseInt(str[1].split("-")[1]);
int d1= Integer.parseInt(str[0].split("-")[2]);
int d2= Integer.parseInt(str[1].split("-")[2]);
Date date1 = sdf.parse(str[0]);
Date date2 = sdf.parse(str[1]);
Date now=new Date();
if(date1.getTime()>date2.getTime()){
System.out.println("输入的开始时间应该比结束时间早！");
System.out.println("请重新输入：");
}else if(now.getTime()>date1.getTime()){
System.out.println("开始时间应该比今日时间晚");
System.out.println("请重新输入：");
}else if(m1>12||m2>12||d1>31||d2>31){
System.out.println("输入错误，请重新输入");
}else {
return time;
}
} catch (Exception e) {
System.out.println("输入错误，请重新输入！");
}
}while(true);
}
public static void main(String[] args) {
}
public static Date readEndWorkDate(Date work_start){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
do{
try {
String endWorkDate=readKeyBoard(10,false);
Date date=sdf.parse(endWorkDate);
if(date.getTime()<work_start.getTime()){
System.out.println("完成时间不能小于兼职开始时间");
System.out.println("请重新输入：");
}else {
return date;
}
} catch (ParseException e) {
System.out.println("输入的时间格式不对！！请重新输入！");
}
}while(true);
}
}
package cptp.view;
import cptp.dao.JobDate;
import cptp.domain.Job;
import cptp.domain.JobType;
import cptp.utility.PrintUtility;
import cptp.utility.TSUtility;
import java.io.IOException;
import java.util.ArrayList;
public class AssignmentDeliveryView {
public void enterDeliveryView() {
PrintUtility.printWelcome("欢迎来到兼职投放界面");
System.out.println("输入”1“开始添加企业信息\t输入”2“返回上级菜单：");
char c = TSUtility.readTwo();
switch (c){
case '1':
increaseInformation();
break;
case '2':
}
}
private void increaseInformation() {
ArrayList<Job> list=null;
try {
list= JobDate.readJob();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
Job job=new Job();
JobType jobType = job.getJobType();
System.out.println("请输入企业的营业执照编号：");
String JID=TSUtility.readKeyBoard(18, false);
job.setJID(JID);
System.out.println("请输入公司名称：");
job.setCompany_name(TSUtility.readKeyBoard(10,false));
System.out.println("请输入投放的职业名称：");
job.setJob_name(TSUtility.readKeyBoard(10,false));
System.out.println("请输入投放的职业的信用等级的要求：");
job.setJob_level(Integer.parseInt(String.valueOf(TSUtility.readFive())));
System.out.println("请输入工作内容：");
job.setJob_content(TSUtility.readKeyBoard(150,false));
System.out.println("请输入招聘人数：");
job.setJob_demand(TSUtility.readRecNum());
System.out.println("请输入工作时间(注意：输入格式为”yyyy-MM-dd到yyyy-MM-dd“)：");
job.setJob_time(TSUtility.readJobTime());
boolean flag;
do {
System.out.println("请输入兼职类型编号：");
String JTID=TSUtility.readKeyBoard(4, false);
flag=true;
for(Job job1:list){
if(job1.getJID().equals(JID)&&job1.getJobType().getJTID().equals(JTID)){
System.out.println("该兼职类型编号已经被本公司其他兼职占用，请重新输入兼职类型编号：");
flag=false;
break;
}
}
if(flag)
jobType.setJTID(JTID);
}while(!flag);
System.out.println("请输入兼职类型名称：");
jobType.setJobType_name(TSUtility.readKeyBoard(4, false));
System.out.println("请输入薪水：");
jobType.setSalary(TSUtility.readDouble());
System.out.println("请输入逾期费用扣除比例：(比如要输入25%，你只需要输入25即可)");
jobType.setDeduct_salary(Integer.parseInt(TSUtility.readKeyBoard(2,false))/100.0);
list.add(job);
try {
JobDate.writeJob(list);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("兼职投放成功！！！！程序将自动返回！");
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new AssignmentDeliveryView().increaseInformation();
}
}
package cptp.view;
import cptp.service.ManagementService;
import cptp.utility.PrintUtility;
import cptp.utility.TSUtility;
import java.io.IOException;
public class BasicInfoMaintenanceView {
ManagementService manSvc=new ManagementService();
public void enterBasicInfoMaView() {
do {
PrintUtility.printWelcome("基本信息维护界面");
PrintUtility.printBaseInfoMenu();
char c = TSUtility.readFive();
switch (c){
case '1':
//兼职等级设置(完成)
manSvc.setJob_level();
break;
case '2':
//兼职类型设置(包括设置逾期费用扣除比例)(完成)
manSvc.setJobType();
break;
case '3':
//用户信用调整(完成)
try {
manSvc.setCredit_rating();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
break;
case '4':
//返回上级菜单
return;
}
}while (true);
}
public static void main(String[] args) {
new BasicInfoMaintenanceView().enterBasicInfoMaView();
}
}
扫一扫
2099
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
