service/

LedgerService.java

package com.example.pkscl.service;

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;
import javax.transaction.Transactional;

import com.example.pkscl.data.entity.ledger.Event;
import com.example.pkscl.data.entity.ledger.Quarter;
import com.example.pkscl.data.entity.ledger.Receipt;
import com.example.pkscl.data.dto.ReceiptModel;
import com.example.pkscl.data.entity.ledger.Receiptdetail;
import com.example.pkscl.data.entity.major.Major;
import com.example.pkscl.repository.EventRepository;
import com.example.pkscl.repository.MajorRepository;
import com.example.pkscl.repository.QuarterRepository;
import com.example.pkscl.repository.ReceiptRepository;
import com.example.pkscl.repository.ReceiptdetailRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class LedgerService {

    private final MajorRepository majorRepository;
    private final QuarterRepository quarterRepository;
    private final EventRepository eventRepository;
    private final ReceiptRepository receiptRepository;
    private final ReceiptdetailRepository receiptdetailRepository;
    
    @Autowired
    public LedgerService(MajorRepository majorRepository, QuarterRepository quarterRepository, EventRepository eventRepository, ReceiptRepository receiptRepository, ReceiptdetailRepository receiptdetailRepository) {
        this.majorRepository = majorRepository;
        this.quarterRepository = quarterRepository;
        this.eventRepository = eventRepository;
        this.receiptRepository = receiptRepository;
        this.receiptdetailRepository = receiptdetailRepository;
    }

    public Map<String, Object> getLedgerData(String major, String position) {
        LinkedHashMap<String, Object> scldata = new LinkedHashMap<>();
        scldata.put("studentPresident", getPresidentData(major));
        scldata.put("quarter", getQuarterData(major, position));
        return scldata;
    }

    // 해당 학과의 major 정보 반환
    public Map<String, Object> getPresidentData(String majorNumber) {

        LinkedHashMap<String, Object> studentPresident = new LinkedHashMap<>();
        Major major = majorRepository.findByMajornumber(Integer.parseInt(majorNumber));
        String majorName = major.getMajorname();
        String name = major.getName();
        String phoneNumber = major.getPhonenumber();
        String email = major.getEmail();
        String majorLogo = major.getMajorlogo();
        
        studentPresident.put("major", majorName);
        studentPresident.put("name", name);
        studentPresident.put("phoneNumber", phoneNumber);
        studentPresident.put("email", email);
        studentPresident.put("majorLogo", majorLogo);

        return studentPresident;
    }

    private String getCurrentDate() {
        java.util.Date date = new java.util.Date();
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(date);
    }


    public boolean getQuarterStatus(String majorNumber, String quarterNumber){
        Quarter quarter = quarterRepository.findByMajornumberAndQuarternumber(Integer.parseInt(majorNumber), quarterNumber);
        if(quarter == null){
            return false;
        }
        String opendate = quarter.getOpendate();
        String closedate = quarter.getClosedate();
        
        if(opendate.compareTo(getCurrentDate()) <= 0 && closedate.compareTo(getCurrentDate()) >= 0){
            return true;
        }else{
            return false;
        }
    }


    public Map<String, Object> getQuarterData(String majorNumber, String position) {
        LinkedHashMap<String, Object> ledger = new LinkedHashMap<>();

        for(int i = 1; i <= 4; i++){
            LinkedHashMap<String, Object> quarterMap = new LinkedHashMap<>();
            String quarterNumber = "quarter" + i;
            boolean status = getQuarterStatus(majorNumber, quarterNumber);
            quarterMap.put("status", String.valueOf(status));
            List<Object> eventList = getEventList(majorNumber, quarterNumber);
            if((!status && position.equals("student")) || eventList.isEmpty()){

            }else{
                quarterMap.put("eventList", eventList);
            }
            ledger.put(quarterNumber, quarterMap);
        }

        return ledger;
    }

    public List<Object> getEventList(String majorNumber, String quarterNumber){
        ArrayList<Object> result = new ArrayList<>();
        Quarter quarter = quarterRepository.findByMajornumberAndQuarternumber(Integer.parseInt(majorNumber), quarterNumber);
        if(quarter == null) return result;
        // 이벤트 리스트를 eventsequence로 오름차순
        List<Event> eventList = eventRepository.findByQuarteridOrderByEventsequence(quarter.getQuarterid());
        for(Event event : eventList){
            LinkedHashMap<String, Object> eventMap = new LinkedHashMap<>();
            String eventNumber = String.valueOf(event.getEventnumber());
            String eventTitle = event.getEventtitle();
            String eventContext = event.getEventcontext();
            List<Object> receiptList = getReceiptList(event.getEventnumber());
            eventMap.put("eventNumber", eventNumber);
            eventMap.put("eventTitle", eventTitle);
            eventMap.put("eventContext", eventContext);
            eventMap.put("receiptList", receiptList);

            result.add(eventMap);
        }
        return result;
    }

    public List<Object> getReceiptList(int eventNumber){
        ArrayList<Object> result = new ArrayList<>();
        List<Receipt> receiptList = receiptRepository.findByEventnumber(eventNumber);
        for(Receipt receipt : receiptList){
            LinkedHashMap<String, Object> receiptMap = new LinkedHashMap<>();
            String receiptNumber = String.valueOf(receipt.getReceiptnumber());
            String receiptTitle = receipt.getReceipttitle();
            LinkedHashMap<String, Object> filename = new LinkedHashMap<>();
            String receiptImg = receipt.getReceiptimg();
            filename.put("name", receiptImg);
            String receiptContext = receipt.getReceiptcontext();
            List<Object> receiptdetailList = getReceiptDetailList(receipt.getReceiptnumber());
            receiptMap.put("receiptNumber", receiptNumber);
            receiptMap.put("receiptTitle", receiptTitle);
            receiptMap.put("receiptImg", filename);
            receiptMap.put("receiptContext", receiptContext);
            receiptMap.put("receiptDetailList", receiptdetailList);

            result.add(receiptMap);
        }
        return result;
    }

    public List<Object> getReceiptDetailList(int receiptNumber){

        ArrayList<Object> result = new ArrayList<>();
        List<Receiptdetail> receiptdetailList = receiptdetailRepository.findByReceiptnumber(receiptNumber);
        for(Receiptdetail receiptdetail : receiptdetailList){
            LinkedHashMap<String, Object> receiptdetailMap = new LinkedHashMap<>();
            String context = receiptdetail.getContext();
            String price = receiptdetail.getPrice();
            String amount = receiptdetail.getAmount();
            receiptdetailMap.put("context", context);
            receiptdetailMap.put("price", price);
            receiptdetailMap.put("amount", amount);
            try{
                String totalAmount = Integer.parseInt(price) * Integer.parseInt(amount) + "";
                receiptdetailMap.put("totalAmount", totalAmount);
            }catch(Exception e){
                receiptdetailMap.put("totalAmount", "");
            }
            result.add(receiptdetailMap);
        }
        return result;
    }
    

    @Transactional
    public void deleteEvent(String eventNumber){
        
        // eventNumber를 가진 receipt 삭제
        deleteReceipt(eventNumber);
        // eventNumber를 가진 event 삭제
        eventRepository.deleteByEventnumber(Integer.parseInt(eventNumber));

    }

    @Transactional
    public void deleteReceipt(String eventNumber){

        List<Receipt> receiptList = receiptRepository.findByEventnumber(Integer.parseInt(eventNumber));
        for(Receipt receipt : receiptList){

            // receiptNumber를 가진 receiptDetail 삭제
            List<Receiptdetail> receiptDetailList = receiptdetailRepository.findByReceiptnumber(receipt.getReceiptnumber());
            for(Receiptdetail receiptDetail : receiptDetailList){
                receiptdetailRepository.delete(receiptDetail);
            }

            // eventNumber를 가진 receipt 삭제
            receiptRepository.delete(receipt);

            // receiptImg 삭제
            String receiptImgPath = receipt.getReceiptimg();
            String fileName = receiptImgPath.substring(receiptImgPath.lastIndexOf("/")+1);
            fileDelete(fileName);
        }

    }

    public Map<String, Object> getLedgerDate(String majorNumber){
        Map<String, Object> result = new LinkedHashMap<>();
        List<Quarter> quarterList = quarterRepository.findByMajornumber(Integer.parseInt(majorNumber));
        for(Quarter quarter : quarterList){
            String quarterNumber = quarter.getQuarternumber();
            String openDate = quarter.getOpendate();
            String closeDate = quarter.getClosedate();
            result.put(quarterNumber, new String[]{openDate, closeDate});
        }
        return result;
    }

    public void putLedgerDate(String majorNumber, String quarterNumber, String openDate, String closeDate){
        Quarter quarter = quarterRepository.findByMajornumberAndQuarternumber(Integer.parseInt(majorNumber), quarterNumber);
        quarter.setOpendate(openDate);
        quarter.setClosedate(closeDate);
        quarterRepository.save(quarter);
    }


    public boolean checkMajorAndEvent(String majorNumber, String eventNumber) {
        int quarterID = eventRepository.findByEventnumber(Integer.parseInt(eventNumber)).getQuarterid();
        if(majorNumber.equals(quarterRepository.findByQuarterid(quarterID).getMajornumber() + "")) return true;
        return false;
    }


    public void patchEvent(String eventNumber, String eventTitle, String eventContext) {
        Event event = eventRepository.findByEventnumber(Integer.parseInt(eventNumber));
        event.setEventtitle(eventTitle);
        event.setEventcontext(eventContext);
        eventRepository.save(event);
    }


    public void addEvent(String majorNumber, String quarter) {
        int quarterID = quarterRepository.findByMajornumberAndQuarternumber(Integer.parseInt(majorNumber), quarter).getQuarterid();
        Event event = new Event();
        event.setQuarterid(quarterID);
        event.setEventtitle("");
        event.setEventcontext("");
        Event savedEvent = eventRepository.save(event);

        // eventSequence 설정
        int eventNumber = savedEvent.getEventnumber();
        event.setEventsequence(eventNumber);
        eventRepository.save(event);
    }


    public void postReceipt(ReceiptModel receiptModel) {

        MultipartFile receiptImg = receiptModel.getReceiptImgFile();
        Receipt receipt = new Receipt();

        if(receiptImg != null){
            log.info("file found");
            String dir = "./static/receiptImg/";
            String filename = new java.text.SimpleDateFormat("yyyyMMddHHmmssSSS").format(new java.util.Date());
            String ext = receiptImg.getOriginalFilename().substring(receiptImg.getOriginalFilename().lastIndexOf("."));
            try {
                fileUpload(filename+ ext, receiptImg);
            } catch (Exception e) {
                e.printStackTrace();
            }
            receipt.setReceiptimg(dir + filename + ext);
        }else{
            log.info("file not found");
            receipt.setReceiptimg("./static/receiptImg/defaultReceiptImg.jpg");
        }

        receipt.setReceipttitle(receiptModel.getReceiptTitle());
        receipt.setReceiptcontext(receiptModel.getReceiptContext());
        receipt.setEventnumber(Integer.parseInt(receiptModel.getEventNumber()));

        receiptRepository.save(receipt);


        List<String> contextList = receiptModel.getContext();
        List<String> priceList = receiptModel.getPrice();
        List<String> amountList = receiptModel.getAmount();

        for(int i = 0; i < contextList.size(); i++){
            Receiptdetail receiptdetail = new Receiptdetail();
            receiptdetail.setContext(contextList.get(i));
            receiptdetail.setPrice(priceList.get(i));
            receiptdetail.setAmount(amountList.get(i));
            receiptdetail.setReceiptnumber(receipt.getReceiptnumber());
            receiptdetailRepository.save(receiptdetail);
        }



    }


    public void putReceipt(ReceiptModel receiptModel) {

        MultipartFile receiptImg = receiptModel.getReceiptImgFile();
        Receipt receipt = receiptRepository.findByReceiptnumber(Integer.parseInt(receiptModel.getReceiptNumber()));

        if(receiptImg != null){
            log.info("file found");
            String dir = "./static/receiptImg/";
            String filename = new java.text.SimpleDateFormat("yyyyMMddHHmmssSSS").format(new java.util.Date());
            String ext = receiptImg.getOriginalFilename().substring(receiptImg.getOriginalFilename().lastIndexOf("."));
            String prevFilePath = receipt.getReceiptimg();
            String prevFileName = prevFilePath.substring(prevFilePath.lastIndexOf("/")+1);

            // 이전 파일 삭제
            fileDelete(prevFileName);
            // 새파일 추가
            try {
                fileUpload(filename+ ext, receiptImg);
            } catch (Exception e) {
                e.printStackTrace();
            }
            receipt.setReceiptimg(dir + filename + ext);
        }else{
            log.info("file not found");
        }

        receipt.setReceipttitle(receiptModel.getReceiptTitle());
        receipt.setReceiptcontext(receiptModel.getReceiptContext());
        receiptRepository.save(receipt);

        List<String> contextList = receiptModel.getContext();
        List<String> priceList = receiptModel.getPrice();
        List<String> amountList = receiptModel.getAmount();
        
        //receiptDetail 삭제
        List<Receiptdetail> receiptDetailList = receiptdetailRepository.findByReceiptnumber(receipt.getReceiptnumber());
        for(Receiptdetail receiptDetail : receiptDetailList){
            receiptdetailRepository.delete(receiptDetail);
        }

        //receiptDetail 추가
        for(int i = 0; i < contextList.size(); i++){
            Receiptdetail receiptdetail = new Receiptdetail();
            receiptdetail.setContext(contextList.get(i));
            receiptdetail.setPrice(priceList.get(i));
            receiptdetail.setAmount(amountList.get(i));
            receiptdetail.setReceiptnumber(receipt.getReceiptnumber());
            receiptdetailRepository.save(receiptdetail);
        }

    }

    @Transactional
    public void deleteReceiptList(String receiptNumberList, String majorNumber, HttpServletResponse response) {
        String[] receiptNumberArray = receiptNumberList.split(",");
        System.out.println(receiptNumberArray);
        for(String receiptNumber : receiptNumberArray){
            if(!checkMajor("receipt", receiptNumber, majorNumber)){
                response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                return;
            }
            // receiptNumber를 가진 receiptDetail 삭제
            List<Receiptdetail> receiptDetailList = receiptdetailRepository.findByReceiptnumber(Integer.parseInt(receiptNumber));
            for(Receiptdetail receiptDetail : receiptDetailList){
                receiptdetailRepository.delete(receiptDetail);
            }

            // receiptNumber를 가진 receipt 삭제
            Receipt receipt = receiptRepository.findByReceiptnumber(Integer.parseInt(receiptNumber));
            receiptRepository.delete(receipt);

            // receiptImg 삭제
            String receiptImgPath = receipt.getReceiptimg();
            String fileName = receiptImgPath.substring(receiptImgPath.lastIndexOf("/")+1);
            fileDelete(fileName);
        }
    }


    public void patchEventSequence(List<String> eventNumberList) {
        // eventNumberList => ["12","13","16","2"] 와 같이 eventNumber를 받아옴
        // eventNumberList의 인덱스를 기준으로 eventSequence를 업데이트
        for(int i = 0; i < eventNumberList.size(); i++){
            Event event = eventRepository.findByEventnumber(Integer.parseInt(eventNumberList.get(i)));
            event.setEventsequence(i + 1);
            eventRepository.save(event);
        }
    }


    public void fileUpload(String filename, MultipartFile file) throws Exception {
        String path = System.getProperty("user.dir") + "/static/static/receiptImg/";
        File saveFile = new File(path + filename);
        file.transferTo(saveFile);
        // 1초 지연
        Thread.sleep(1000);
    }

    public void fileDelete(String filename) {
        if(filename.equals("defaultReceiptImg.jpg")) return;
        String path = System.getProperty("user.dir") + "/static/static/receiptImg/";
        File saveFile = new File(path + filename);
        saveFile.delete();
    }

    public boolean checkMajor(String object, String objectNumber, String majorNumber) {
        log.info("object : " + object + ", objectNumber : " + objectNumber + ", majorNumber : " + majorNumber);
        if(object.equals("event")){
            log.info("event");
            Event event = eventRepository.findByEventnumber(Integer.parseInt(objectNumber));
            Quarter quarter = quarterRepository.findByQuarterid(event.getQuarterid());
            if(Integer.parseInt(majorNumber) != quarter.getMajornumber()) return false;

        }else if(object.equals("receipt")){
            log.info("receipt");
            Receipt receipt = receiptRepository.findByReceiptnumber(Integer.parseInt(objectNumber));
            Event event = eventRepository.findByEventnumber(receipt.getEventnumber());
            Quarter quarter = quarterRepository.findByQuarterid(event.getQuarterid());
            if(Integer.parseInt(majorNumber) != quarter.getMajornumber()) return false;
        }

        return true;
    }

    
    
}

MemberManagementService.java

package com.example.pkscl.service;

import com.example.pkscl.data.entity.major.Major;
import com.example.pkscl.data.entity.member.President;
import com.example.pkscl.data.entity.member.Student;
import com.example.pkscl.repository.MajorRepository;
import com.example.pkscl.repository.PresidentRepository;
import com.example.pkscl.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import javax.servlet.http.HttpServletResponse;

@Service
public class MemberManagementService {

    private StudentRepository studentRepository;
    private PresidentRepository presidentRepository;
    private MajorRepository majorRepository;

    @Autowired
    public MemberManagementService(StudentRepository studentRepository, PresidentRepository presidentRepository, MajorRepository majorRepository) {
        this.studentRepository = studentRepository;
        this.presidentRepository = presidentRepository;
        this.majorRepository = majorRepository;
    }


    public LinkedHashMap<String, Object> getStudentData(String majorNumber) {

        // 학생을 리스트 형식으로 받아옴
        List<Student> students= studentRepository.findByMajornumber(Integer.parseInt(majorNumber));

        LinkedHashMap<String, Object> studentList = new LinkedHashMap<>();
        List<LinkedHashMap<String, Object>> waitingList = new ArrayList<>();
        List<LinkedHashMap<String, Object>> refusalList = new ArrayList<>();
        List<LinkedHashMap<String, Object>> approvalList = new ArrayList<>();
        
        // 로직 작성
        // 필요한 데이터만 추출
        for(Student student : students) {
            String status = student.getStatus();
            String studentId = student.getStudentid();
            String name = student.getName();
            String email = student.getEmail();
            String certfilepath = student.getCertfilepath();

            LinkedHashMap<String, Object> studentInfo = new LinkedHashMap<>();
            studentInfo.put("stdID", studentId);
            studentInfo.put("name", name);
            studentInfo.put("email", email);
            studentInfo.put("studentImgPath", certfilepath);

            if(status.equals("waiting")) {
                    
                waitingList.add(studentInfo);
            }
            else if (status.equals("refusal")) {
                refusalList.add(studentInfo);
            }
            else if (status.equals("approval")) {
                approvalList.add(studentInfo);
            }
        }

        studentList.put("waiting", waitingList );
        studentList.put("refusal", refusalList );
        studentList.put("approval", approvalList );

        return studentList;
    }

    public void patchStudentStatus(String email, String patchStatus, String majorNumber) {
        Student student = studentRepository.findByEmail(email);
        if(student.getMajornumber() == Integer.parseInt(majorNumber)) {
            student.setStatus(patchStatus);
            studentRepository.save(student);
        }
    }

    public LinkedHashMap<String, Object> getPresidentData() {
        
        // 학과회장을 리스트 형식으로 받아옴
        List<President> presidents = presidentRepository.findAll();

        LinkedHashMap<String, Object> presidentList = new LinkedHashMap<>();
        List<LinkedHashMap<String, Object>> waitingList = new ArrayList<>();
        List<LinkedHashMap<String, Object>> refusalList = new ArrayList<>();
        List<LinkedHashMap<String, Object>> approvalList = new ArrayList<>();

        for(President president : presidents) {
            String status = president.getStatus();
            int majorNumber = president.getMajornumber();
            String majorName = majorRepository.findByMajornumber(majorNumber).getMajorname();
            String email = president.getEmail();
            String stdID = president.getStudentid();
            String name = president.getName();
            String phoneNumber = president.getPhonenumber();

            LinkedHashMap<String, Object> presidentInfo = new LinkedHashMap<>();
            presidentInfo.put("major", majorName);
            presidentInfo.put("email", email);
            presidentInfo.put("stdID", stdID);
            presidentInfo.put("name", name);
            presidentInfo.put("phoneNumber", phoneNumber);

            if(status.equals("waiting")) {
                waitingList.add(presidentInfo);
            }
            else if (status.equals("refusal")) {
                refusalList.add(presidentInfo);
            }
            else if (status.equals("approval")) {
                approvalList.add(presidentInfo);
            }
        }

        presidentList.put("waiting", waitingList );
        presidentList.put("refusal", refusalList );
        presidentList.put("approval", approvalList );

        return presidentList;
        
    }

    public void patchPresidentStatus(String email, String patchStatus, HttpServletResponse response) {

        if(patchStatus.equals("approval")) {
            President newPresident = presidentRepository.findByEmail(email);
            Major major = majorRepository.findByMajornumber(newPresident.getMajornumber());
            System.out.println(major);
            if(!major.getEmail().equals("PKSCL")){
                President prevPresident = presidentRepository.findByEmail(major.getEmail());
                System.out.println(prevPresident);
                if(prevPresident.getStatus().equals("approval")) {
                    response.setStatus(409);
                    return;
                }
            }
        }
    
        President president = presidentRepository.findByEmail(email);
        president.setStatus(patchStatus);
        presidentRepository.save(president);
    }

    public void patchMajorPresident(String presidentEmail, String newPresidentEmail, String majorNumber, HttpServletResponse response) {

        President newPresident = presidentRepository.findByEmail(newPresidentEmail);
        if(newPresident == null || newPresident.getMajornumber() != Integer.parseInt(majorNumber)) {
            response.setStatus(400);
            return;
        }

        newPresident.setStatus("approval");
        presidentRepository.save(newPresident);
        President prevPresident = presidentRepository.findByEmail(presidentEmail);
        prevPresident.setStatus("waiting");
        presidentRepository.save(prevPresident);
    }
    
}

ProfileService.java

package com.example.pkscl.service;

import com.example.pkscl.repository.PresidentRepository;
import com.example.pkscl.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.io.File;
import java.util.LinkedHashMap;
import java.util.Map;

import com.example.pkscl.data.entity.major.Major;
import com.example.pkscl.data.entity.member.President;
import com.example.pkscl.data.entity.member.Student;
import com.example.pkscl.repository.MajorRepository;
import org.springframework.web.multipart.MultipartFile;

import javax.transaction.Transactional;


@Service
public class ProfileService {

    private final StudentRepository studentRepository;
    private final PresidentRepository presidentRepository;
    private final MajorRepository majorRepository;
    private final PasswordEncoder passwordEncoder;


    @Autowired
    public ProfileService(StudentRepository studentRepository, PresidentRepository presidentRepository, MajorRepository majorRepository,  PasswordEncoder passwordEncoder) {
        this.studentRepository = studentRepository;
        this.presidentRepository = presidentRepository;
        this.majorRepository = majorRepository;
        this.passwordEncoder = passwordEncoder;
    }


    public Map<String,Object> getProfileData(String position, String email, String majorNumber) {

        Map<String,Object> profileInfo = new LinkedHashMap<>();
        // 학생을 리스트 형식으로 받아옴
        if(position == "student") {
            Student profileData = studentRepository.findByEmail(email);

            String studentId = profileData.getStudentid();
            String name = profileData.getName();
            String pEmail = profileData.getEmail();
            String certfilepath = profileData.getCertfilepath();

            LinkedHashMap<String, Object> certfile = new LinkedHashMap<>();
            certfile.put("name", certfilepath);

            profileInfo.put("stdID", studentId);
            profileInfo.put("major", majorNumber);
            profileInfo.put("name", name);
            profileInfo.put("email", pEmail);
            profileInfo.put("certFile", certfile);
        }

        else if(position == "president"){
            President profileData = presidentRepository.findByEmail(email);
            Major major = majorRepository.findByMajornumber(Integer.parseInt(majorNumber));

            String studentId = profileData.getStudentid();
            String name = profileData.getName();
            String phoneNumber = profileData.getPhonenumber();
            String pEmail = profileData.getEmail();
            String majorLogo = major.getMajorlogo();

            LinkedHashMap<String, Object> majorLogoMap = new LinkedHashMap<>();
            majorLogoMap.put("name", majorLogo);

            profileInfo.put("stdID", studentId);
            profileInfo.put("major", majorNumber);
            profileInfo.put("name", name);
            profileInfo.put("phoneNumber", phoneNumber);
            profileInfo.put("email", pEmail);
            profileInfo.put("majorLogo", majorLogoMap);
        }

        return profileInfo;

    }

    public void fileUploadStd(String filename, MultipartFile file) throws Exception {
        String path = System.getProperty("user.dir") + "/static/static/studentCertFile/";
        File saveFile = new File(path + filename);
        file.transferTo(saveFile);
    }

    public void fileUploadLogo(String filename, MultipartFile file) throws Exception {
        String path = System.getProperty("user.dir") + "/static/static/majorLogo/";
        File saveFile = new File(path + filename);
        file.transferTo(saveFile);
    }

    @Transactional
    public void putStudentProfileData(String email, String stdID, int major,String name, String certFilePath) {
        Student profileData = studentRepository.findByEmail(email);
        profileData.setStudentid(stdID);
        profileData.setMajornumber(major);
        profileData.setName(name);
        profileData.setStatus("waiting");
        if(certFilePath != null) {
            profileData.setCertfilepath("./static/studentCertFile/"+certFilePath);
        }
        studentRepository.save(profileData);
    }

    @Transactional
    public void putPresidentProfileData(String email, String stdID, String name, String phoneNumber, String majorLogoPath, String inputMajorNumber) {
        President profileData = presidentRepository.findByEmail(email);
        profileData.setStudentid(stdID);
        profileData.setName(name);
        profileData.setPhonenumber(phoneNumber);

        if(!profileData.getStatus().equals("approval")) {
            profileData.setMajornumber(Integer.parseInt(inputMajorNumber));
        }

        presidentRepository.save(profileData);

        if(majorLogoPath != null) {
            int majorNumber = presidentRepository.findByEmail(email).getMajornumber();
            Major major = majorRepository.findByMajornumber(majorNumber);
            major.setMajorlogo("./static/majorLogo/" + majorLogoPath);
            majorRepository.save(major);    
        }

    }

    public String getStudentPassword(String email) {
        Student student = studentRepository.findByEmail(email);
        return student.getPassword();
    }

    public String getPresidentPassword(String email){
        President president = presidentRepository.findByEmail(email);
        return president.getPassword();
    }

    public void patchStudentPassword(String email, String newPassword){
        Student student = studentRepository.findByEmail(email);
        student.setPassword(passwordEncoder.encode(newPassword));

        studentRepository.save(student);
    }

    public void patchPresidentPassword(String email, String newPassword){
        President president = presidentRepository.findByEmail(email);
        president.setPassword(passwordEncoder.encode(newPassword));

        presidentRepository.save(president);
    }
}

SignInService.java

package com.example.pkscl.service;

import com.example.pkscl.data.entity.member.Admin;
import com.example.pkscl.data.entity.member.President;
import com.example.pkscl.data.entity.member.Student;
import com.example.pkscl.repository.AdminRepository;
import com.example.pkscl.repository.PresidentRepository;
import com.example.pkscl.repository.StudentRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class SignInService {
    
    private final PasswordEncoder passwordEncoder;
    private final PresidentRepository presidentRepository;
    private final StudentRepository studentRepository;
    private final AdminRepository adminRepository;

    @Autowired
    public SignInService(PasswordEncoder passwordEncoder, PresidentRepository presidentRepository, StudentRepository studentRepository, AdminRepository adminRepository) {
        this.passwordEncoder = passwordEncoder;
        this.presidentRepository = presidentRepository;
        this.studentRepository = studentRepository;
        this.adminRepository = adminRepository;
    }

    public String encode(String password) {
        return passwordEncoder.encode(password);
    }

    // 비밀번호 일치 여부 확인
    public boolean presidentMatch(String password, String email) {
        President president = presidentRepository.findByEmail(email);
        if(president == null) return false;
        return passwordEncoder.matches(password, president.getPassword());
    }

    public boolean studentMatch(String password, String email) {
        Student student = studentRepository.findByEmail(email);
        if (student == null) return false;
        return passwordEncoder.matches(password, student.getPassword());
    }

    public boolean adminMatch(String password, String id) {
        Admin admin = adminRepository.findById(id);
        if (admin == null) return false;
        return passwordEncoder.matches(password, admin.getPassword());
    }

    //이메일로 부터 학생 학과번호 가져오기
    public int getStudentMajor(String email) {
        Student student = studentRepository.findByEmail(email);
        if(student == null) return -1;
        return student.getMajornumber();
    }

    public int getPresidentMajor(String email) {
        President president = presidentRepository.findByEmail(email);
        if (president == null) return -1;
        return president.getMajornumber();
    }

    public String getStudentStatus(String email) {
        Student student = studentRepository.findByEmail(email);
        if (student == null) return "";
        return student.getStatus();
    }

    public String getPresidentStatus(String email) {
        President president = presidentRepository.findByEmail(email);
        if (president == null) return "";
        return president.getStatus();
    }

    public void withdrawalStudent(String email) {
        Student student = studentRepository.findByEmail(email);
        studentRepository.delete(student);
    }

    public void withdrawalPresident(String email) {
        President president = presidentRepository.findByEmail(email);
        presidentRepository.delete(president);
    }

}

SignUpService.java

package com.example.pkscl.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.example.pkscl.repository.StudentCertemailRepository;
import com.example.pkscl.data.entity.major.Major;
import com.example.pkscl.data.entity.member.President;
import com.example.pkscl.data.entity.member.Student;
import com.example.pkscl.data.entity.temp.PresidentCertemail;
import com.example.pkscl.data.entity.temp.StudentCertemail;
import com.example.pkscl.repository.MajorRepository;
import com.example.pkscl.repository.PresidentCertemailRepository;
import com.example.pkscl.repository.PresidentRepository;
import com.example.pkscl.repository.StudentRepository;

@Service
public class SignUpService {

    private StudentRepository studentRepository;
    private PresidentRepository presidentRepository;
    private StudentCertemailRepository studentCertemailRepository;
    private PresidentCertemailRepository presidentCertemailRepository;
    private MajorRepository majorRepository;
    private PasswordEncoder passwordEncoder;

    @Autowired
    public SignUpService(StudentRepository studentRepository, PresidentRepository presidentRepository, StudentCertemailRepository studentCertemailRepository, PresidentCertemailRepository presidentCertemailRepository, MajorRepository majorRepository, PasswordEncoder passwordEncoder) {
        this.studentRepository = studentRepository;
        this.presidentRepository = presidentRepository;
        this.studentCertemailRepository = studentCertemailRepository;
        this.presidentCertemailRepository = presidentCertemailRepository;
        this.majorRepository = majorRepository;
        this.passwordEncoder = passwordEncoder;
    }

    public boolean signUpStudent(Student student) {
        StudentCertemail certemail = studentCertemailRepository.findByEmail(student.getEmail());
        if(certemail == null || certemail.getStatus() == 0) return false;
        student.setPassword(passwordEncoder.encode(student.getPassword()));
        student.setStatus("waiting");
        studentRepository.save(student);
        return true;
    }

    public boolean signUpPresident(President president) {
        PresidentCertemail certemail = presidentCertemailRepository.findByEmail(president.getEmail());
        if(certemail == null || certemail.getStatus() == 0) return false;
        president.setPassword(passwordEncoder.encode(president.getPassword()));
        president.setStatus("waiting");
        presidentRepository.save(president);
        return true;
    }

    public boolean studentCheckEmail(String email) {
        Student student = studentRepository.findByEmail(email);
        if(student != null) return false;
        return true;
    }

    public boolean presidentCheckEmail(String email) {
        President president = presidentRepository.findByEmail(email);
        if(president != null) return false;
        return true;
    }

    public void fileUpload(String filename, MultipartFile file) throws Exception {
        String path = System.getProperty("user.dir") + "/static/static/studentCertFile/";
        File saveFile = new File(path + filename);
        file.transferTo(saveFile);
    }

    // major의 majorname 목록 반환
    public Map<String,Object> getMajorList() {
        List<String> majorList = majorRepository.findAll().stream().map(Major::getMajorname).collect(Collectors.toList());
        LinkedHashMap<String,Object> result = new LinkedHashMap<>();
        result.put("majorList", majorList);
        return result;
    }
}

SMTPService.java

package com.example.pkscl.service;

import java.io.File;
import java.io.IOException;
import java.security.Key;
import java.util.Date;

import javax.crypto.spec.SecretKeySpec;
import javax.mail.Message;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.xml.bind.DatatypeConverter;

import com.example.pkscl.repository.StudentCertemailRepository;
import com.example.pkscl.data.entity.member.President;
import com.example.pkscl.data.entity.member.Student;
import com.example.pkscl.data.entity.temp.PresidentCertemail;
import com.example.pkscl.data.entity.temp.StudentCertemail;
import com.example.pkscl.repository.PresidentCertemailRepository;
import com.example.pkscl.repository.PresidentRepository;
import com.example.pkscl.repository.StudentRepository;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMailMessage;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
public class SMTPService {

    private final JavaMailSender mailSender;
    private final StudentRepository studentRepository;
    private final PresidentRepository presidentRepository;
    private final StudentCertemailRepository studentCertemailRepository;
    private final PresidentCertemailRepository presidentCertemailRepository;
    private final PasswordEncoder passwordEncoder;


    @Autowired
    public SMTPService(JavaMailSender mailSender, StudentRepository studentRepository, PresidentRepository presidentRepository, StudentCertemailRepository studentCertemailRepository, PresidentCertemailRepository presidentCertemailRepository, PasswordEncoder passwordEncoder) {
        this.mailSender = mailSender;
        this.studentRepository = studentRepository;
        this.presidentRepository = presidentRepository;
        this.studentCertemailRepository = studentCertemailRepository;
        this.presidentCertemailRepository = presidentCertemailRepository;
        this.passwordEncoder = passwordEncoder;
    }

    private static final String SECRET_KEY = "tempSecretKey";

    public void sendEmail(String toEmail
            , String subject
            , String body) {

        MimeMessage message = mailSender.createMimeMessage();
        try {
            message.setFrom(new InternetAddress("[e-mail]"));
            message.setRecipient(Message.RecipientType.TO, new InternetAddress(toEmail));
            message.setSubject(subject);
            message.setText(body, "utf-8", "html");
            mailSender.send(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String generateToken(String content, long exptime){
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(SECRET_KEY);
        Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

        return Jwts.builder()
                .setSubject(content)
                .signWith(signatureAlgorithm, signingKey)
                .setExpiration(new Date(System.currentTimeMillis()+exptime))
                .compact();
    }

    public String decodeToken(String token){
        return Jwts.parser()
                .setSigningKey(DatatypeConverter.parseBase64Binary(SECRET_KEY))
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }

    // 인증용 이메일 발송
    public void sendEmailAuth(String toEmail, String position) {

        // 토큰 및 url 생성
        String token = generateToken(toEmail, (2*1000*60));
        String subject = "회원가입 인증 메일입니다.";

        // 안내문구
        String url = "https://pkscl.kro.kr/verify/token/"+ position +"/?token=" + token;
        
        // 이메일 정보 DB 저장
        if(position.equals("student")){
            StudentCertemail studentCertemail = new StudentCertemail();
            studentCertemail.setEmail(toEmail);
            studentCertemailRepository.save(studentCertemail);
        }
        else if(position.equals("president")){
            PresidentCertemail presidentCertemail = new PresidentCertemail();
            presidentCertemail.setEmail(toEmail);
            presidentCertemailRepository.save(presidentCertemail);
        }
        log.info("sendEmail1");

        try {
            // File input = new File("src/main/resources/static/emailAuthentication.html");
            File input = new File("/home/pkscl/static/static/smtpForm/emailAuthentication.html");
            Document html = Jsoup.parse(input, "UTF-8");
            // "인증 링크" 위치에 url 치환
            String body = html.toString();
            StringBuilder sb = new StringBuilder(body);
            int index = sb.indexOf("인증 링크");
            sb.replace(index, index+5, url);
            body = sb.toString();
            sendEmail(toEmail, subject, body);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 토큰 인증
    public boolean studentVerifyToken(String token){
        try{
            StudentCertemail certemail = studentCertemailRepository.findByEmail(decodeToken(token));
            if(certemail == null){
                return false;
            }
            // status를 1로 변경
            certemail.setStatus(1);
            studentCertemailRepository.save(certemail);
            return true;
        }catch(Exception e){
            return false;
        }
    }

    public boolean presidentVerifyToken(String token){
        try{
            PresidentCertemail certemail = presidentCertemailRepository.findByEmail(decodeToken(token));
            if(certemail == null){
                return false;
            }
            // status를 1로 변경
            certemail.setStatus(1);
            presidentCertemailRepository.save(certemail);
            return true;
        }catch(Exception e){
            return false;
        }
    }

    public Integer studentTempPassword(String email, String name, String studentId){

        // 이메일로 사용자 검색
        Student student = studentRepository.findByEmail(email);
        if (student == null) return -1;
        if (!student.getName().equals(name) || !student.getStudentid().equals(studentId)) return -2;

        // 임시 비밀번호 숫자 6자리로 생성
        String tempPassword = "PKSCL";
        for(int i=0; i<5; i++){
            tempPassword += (int)(Math.random()*10);
        }
        String subject = "임시 비밀번호 발급";
    
        try {
            // File input = new File("src/main/resources/static/findPassword.html");
            File input = new File("/home/pkscl/static/static/smtpForm/findPassword.html");
            Document html = Jsoup.parse(input, "UTF-8");
            String body = html.toString();
            StringBuilder sb = new StringBuilder(body);
            int index = sb.indexOf("임시비밀번호");
            sb.replace(index, index+6, tempPassword);
            body = sb.toString();
            
            sendEmail(email, subject, body);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 비밀번호 변경
        student.setPassword(passwordEncoder.encode(tempPassword));
        studentRepository.save(student);
        return 1;
    }
    
    public Integer presidentTempPassword(String email, String name, String studentId){

        // 이메일로 사용자 검색
        President president = presidentRepository.findByEmail(email);
        if (president == null) return -1;
        if (!president.getName().equals(name) || !president.getStudentid().equals(studentId)) return -2;

        // 임시 비밀번호 숫자 6자리로 생성
        String tempPassword = "PKSCL";
        for(int i=0; i<5; i++){
            tempPassword += (int)(Math.random()*10);
        }
        String subject = "임시 비밀번호 발급";
    
        // 메일 전송
        try {
            // File input = new File("src/main/resources/static/findPassword.html");
            File input = new File("/home/pkscl/static/static/smtpForm/findPassword.html");
            Document html = Jsoup.parse(input, "UTF-8");
            String body = html.toString();
            StringBuilder sb = new StringBuilder(body);
            int index = sb.indexOf("임시비밀번호");
            sb.replace(index, index+6, tempPassword);
            body = sb.toString();
            
            sendEmail(email, subject, body);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 비밀번호 변경
        president.setPassword(passwordEncoder.encode(tempPassword));
        presidentRepository.save(president);
        return 1;
    }

    public boolean checkEmailForm(String email) {
        // 이메일 형식 체크
        //@pukyong.ac.kr 로 끝나지 않으면 false
        if(!email.endsWith("@pukyong.ac.kr")) return false;
        return true;
    }
}