人员管理系统第一次提交

src/main/java/com/example/personnelmanager/PersonnelmanagerApplication.java

+package com.example.personnelmanager;
+
+import com.example.personnelmanager.dao.SimpleJpaRepositoryImpl;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@SpringBootApplication
+@EnableJpaRepositories(repositoryBaseClass = SimpleJpaRepositoryImpl.class)
+public class PersonnelmanagerApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(PersonnelmanagerApplication.class, args);
+    }
+
+}

src/main/java/com/example/personnelmanager/common/config/BeanConfig.java

+package com.example.personnelmanager.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class BeanConfig
+ * @packageName com.example.demo.common.config
+ * @data 2020/4/21
+ **/
+
+@Configuration
+public class BeanConfig {
+
+    @Bean
+    public Validator validator(){
+        ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
+        return validatorFactory.getValidator();
+    };
+
+    @Bean
+    public Authentication authentication(){
+        return SecurityContextHolder.getContext().getAuthentication();
+    }
+
+}

src/main/java/com/example/personnelmanager/common/config/CorsConfig.java

+package com.example.personnelmanager.common.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class CorsConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowedOrigins("*")
+                .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
+                .allowCredentials(true)
+                .maxAge(3600)
+                .allowedHeaders("*");
+    }
+}
\ No newline at end of file

src/main/java/com/example/personnelmanager/common/config/SecurityWebConfig.java

+package com.example.personnelmanager.common.config;
+
+import com.example.personnelmanager.entity.UserDetail;
+import com.example.personnelmanager.service.UserServer;
+import com.google.gson.Gson;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.AuthenticationEntryPoint;
+import org.springframework.security.web.authentication.AuthenticationFailureHandler;
+import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
+import org.springframework.stereotype.Service;
+
+import javax.servlet.ServletException;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+@EnableWebSecurity
+@EnableGlobalMethodSecurity(jsr250Enabled = true)
+public class SecurityWebConfig extends WebSecurityConfigurerAdapter {
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http.cors().and().formLogin()
+                .loginProcessingUrl("/api/user/login")
+                .successHandler(new CustomAuthenticationSuccessHandler())
+                .failureHandler(new CustomAuthenticationFailureHandler())
+                .permitAll()
+                .usernameParameter("username")
+                .passwordParameter("password")
+                .and()
+                .authorizeRequests()
+//                .antMatchers("/user/*").hasRole("NORMAL")
+                .anyRequest()
+//                .authenticated()
+                .permitAll()
+                .and()
+                .logout()
+                .logoutUrl("/user/logout").permitAll()
+
+                .and()
+                .sessionManagement()
+                .and()
+                .csrf().disable();
+        http.exceptionHandling()
+                .authenticationEntryPoint(new CustomAuthenticationEntryPoint());
+    }
+
+    @Override
+    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
+        auth.userDetailsService(new MyUserDetailsService()).passwordEncoder(passwordEncoder());
+        super.configure(auth);
+    }
+
+    @Service
+    public class MyUserDetailsService implements UserDetailsService {
+
+        @Autowired
+        UserServer userServer;
+
+        @Override
+        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+            return   userServer.selectByUserName(username);
+        }
+    }
+
+    /***
+     * 登录成功后干些啥
+     */
+    public static class CustomAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
+
+        @Override
+        public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
+                                            Authentication authentication) throws IOException{
+            httpServletResponse.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_UTF8_VALUE);
+            ServletOutputStream servletOutputStream = httpServletResponse.getOutputStream();
+            UserDetail user = (UserDetail) authentication.getPrincipal();
+            Map<String, Object> result = new HashMap<>(3);
+            result.put("username", user.getUsername());
+            result.put("mgs","登录成功");
+            servletOutputStream.write(new Gson().toJson(result).getBytes("utf-8"));
+            servletOutputStream.flush();
+            servletOutputStream.close();
+        }
+    }
+
+    /**
+     * 登录失败了干些啥
+     */
+    public static class CustomAuthenticationFailureHandler implements AuthenticationFailureHandler {
+
+        @Override
+        public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
+                                            AuthenticationException e) throws IOException, ServletException {
+            httpServletResponse.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_UTF8_VALUE);
+            httpServletResponse.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+            ServletOutputStream servletOutputStream = httpServletResponse.getOutputStream();
+            Map<String, Object> result = new HashMap<>(1);
+            result.put("msg", e.getMessage());
+            servletOutputStream.write(new Gson().toJson(result).getBytes("utf-8"));
+            servletOutputStream.flush();
+            servletOutputStream.close();
+        }
+    }
+
+    /**
+     * 没有登录干些啥
+     */
+    public static class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {
+
+        @Override
+        public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
+                             AuthenticationException e) throws IOException, ServletException {
+            httpServletResponse.setStatus(HttpStatus.UNAUTHORIZED.value());
+        }
+    }
+
+}

src/main/java/com/example/personnelmanager/common/config/SwaggerConfig.java

+package com.example.personnelmanager.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.ApiInfo;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class SwaggerConfig
+ * @packageName com.example.demo.common.config
+ * @data 2020/4/20
+ **/
+
+@Configuration
+@EnableSwagger2
+public class SwaggerConfig {
+    private ApiInfo apiInfo() {
+        return new ApiInfoBuilder().title("API接口文档")
+                .description("简易图书借阅系统")
+                .termsOfServiceUrl("http://localhost:8080/")
+                .version("1.0.0")
+                .build();
+    }
+    @Bean
+    public Docket createRestApi() {
+        return new Docket(DocumentationType.SWAGGER_2)
+                .apiInfo(apiInfo())
+                .select()
+                .apis(RequestHandlerSelectors.basePackage("com.example.demo.controller")) //这里写的是API接口所在的包位置
+                .paths(PathSelectors.any())
+                .build();
+    }
+}

src/main/java/com/example/personnelmanager/common/exception/GlobalException.java

+package com.example.personnelmanager.common.exception;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class GlobalException
+ * @packageName com.example.demo.common.exception
+ * @description
+ * @data 2020/4/14
+ **/
+public class GlobalException extends RuntimeException {
+
+    public GlobalException(String message) {
+        super(message);
+    }
+
+}

src/main/java/com/example/personnelmanager/common/exception/GlobalExceptionHandler.java

+package com.example.personnelmanager.common.exception;
+
+
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.fasterxml.jackson.core.JsonParseException;
+import org.hibernate.JDBCException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.converter.HttpMessageConversionException;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.http.converter.HttpMessageNotWritableException;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.validation.BindException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+/**
+ * 描述：错误处理类
+ * 所有的报错信息都会通过本层的方法向外界返回
+ *
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ErrorController
+ * @packageName com.example.demo.controller
+ * @description
+ * @data 2020/4/7
+ **/
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    /**
+     * 描述：所有的报错信息都会通过这个方法处理并通过统一的返回方式进行返回
+     *
+     * @param e  报错信息
+     * @Return : com.example.demo.entity.ResultObj
+     * @Author : HuangXiahao
+     * @Date : 2020/4/10 15:14
+    */
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(Exception.class)
+    public ResultObj errorMessage(Exception e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),e.getMessage());
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(BindException.class)
+    public ResultObj errorMessage(BindException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),e.getAllErrors().get(0).getDefaultMessage());
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResultObj errorMessage(MethodArgumentNotValidException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(JDBCException.class)
+    public ResultObj errorMessage(JDBCException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),"关键参数未填写");
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.UNAUTHORIZED)
+    @ExceptionHandler(AuthenticationException.class)
+    public ResultObj errorMessage(AuthenticationException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),e.getMessage());
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    public ResultObj errorMessage(HttpMessageNotReadableException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),"上传内容格式不正确");
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(HttpMessageConversionException.class)
+    public ResultObj errorMessage(HttpMessageConversionException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),"上传内容格式不正确");
+        return resultObj;
+    }
+
+    @ResponseBody
+    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
+    @ExceptionHandler(IOException.class)
+    public ResultObj errorMessage(IOException e){
+        ResultObj resultObj = new ResultObj(new HashMap<>(),"文件上传失败");
+        return resultObj;
+    }
+}

src/main/java/com/example/personnelmanager/common/utils/AuthenticationUtils.java

+package com.example.personnelmanager.common.utils;
+
+import com.example.personnelmanager.entity.UserDetail;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+
+/**
+ * 描述：用户实体相关工具类
+ *
+ * @author HuangXiahao
+ * @version V1.0
+ * @class AuthenticationUtils
+ * @packageName com.example.personnelmanager.common.utils
+ * @data 2020/5/14
+ **/
+public class AuthenticationUtils {
+
+    //获取当前登录用户
+    public static UserDetail getAuthentication(){
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication.getPrincipal().equals("anonymousUser")){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        return (UserDetail) authentication.getPrincipal();
+    }
+
+}

src/main/java/com/example/personnelmanager/common/validIGroup/GroupDelete.java

+package com.example.personnelmanager.common.validIGroup;
+
+public interface GroupDelete {
+}

src/main/java/com/example/personnelmanager/common/validIGroup/GroupGetOne.java

+package com.example.personnelmanager.common.validIGroup;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class GroupGetOne
+ * @packageName com.example.personnelmanager.common.validIGroup
+ * @data 2020/5/14
+ **/
+public interface GroupGetOne {
+}

src/main/java/com/example/personnelmanager/common/validIGroup/GroupSave.java

+package com.example.personnelmanager.common.validIGroup;
+
+public interface GroupSave {
+}

src/main/java/com/example/personnelmanager/common/validIGroup/GroupSaveImage.java

+package com.example.personnelmanager.common.validIGroup;
+
+public interface GroupSaveImage {
+}

src/main/java/com/example/personnelmanager/common/validIGroup/GroupUpdate.java

+package com.example.personnelmanager.common.validIGroup;
+
+public interface GroupUpdate {
+}

src/main/java/com/example/personnelmanager/controller/CertificateController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupSaveImage;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.CertificateImage;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+
+import com.example.personnelmanager.entity.vo.CertificatePageableVo;
+import com.example.personnelmanager.service.CertificateImageService;
+import com.example.personnelmanager.service.CertificateService;
+import com.example.personnelmanager.service.ContractImageService;
+import com.example.personnelmanager.service.ContractService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.util.ClassUtils;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.UUID;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class CertificateController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/18
+ **/
+@RestController
+@RequestMapping("/api/certificate")
+public class CertificateController {
+
+    @Autowired
+    CertificateService certificateService;
+
+    @Autowired
+    CertificateImageService certificateImageService;
+
+    @RequestMapping(method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<Certificate> addContract(@Validated(GroupSave.class) @RequestBody Certificate certificate) {
+        Certificate addCertificate = certificateService.addEntity(certificate);
+        ResultObj<Certificate> resultObj = new ResultObj(addCertificate, addCertificate != null ? "success" : "插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/list", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj getContractPage(@RequestBody CertificatePageableVo certificatePageableVo) {
+        return new ResultObj(certificateService.getList(certificatePageableVo.getCertificate(), certificatePageableVo.getPageable()), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delContract(@Validated(GroupDelete.class) @RequestBody Certificate certificate) {
+        return new ResultObj(certificateService.delete(certificate.getCertificateId()), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getContract(@Validated(GroupDelete.class) Certificate certificate) {
+        return new ResultObj(certificateService.getOne(certificate.getCertificateId()), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updateContract(@Validated(GroupUpdate.class) @RequestBody Certificate certificate) {
+        return new ResultObj(certificateService.update(certificate), "success");
+    }
+
+    @RequestMapping(value = "/file",method = RequestMethod.POST)
+    public CertificateImage addContractImage(@RequestParam("file") MultipartFile file, @Validated(GroupSaveImage.class) Long certificateId) throws IOException {
+        if (!file.isEmpty()) {
+            CertificateImage certificateImage = new CertificateImage();
+            //获取文件名
+            String fileName = file.getOriginalFilename();
+            //获取文件后缀
+            String suffixName = fileName.substring(fileName.lastIndexOf("."));
+            //重新生成文件名
+            fileName = UUID.randomUUID() + suffixName;
+            //指定本地存入路径
+            String path = ClassUtils.getDefaultClassLoader().getResource("static/images/").getPath();
+            file.transferTo(new File(path + fileName));
+            Certificate certificate = new Certificate();
+            certificate.setCertificateId(certificateId);
+            certificateImage.setCertificate(certificate);
+            certificateImage.setUrl("/images/" + fileName);
+            certificateImageService.addEntity(certificateImage);
+        } else {
+            throw new GlobalException("文件是空的");
+        }
+        return null;
+    }
+
+}

src/main/java/com/example/personnelmanager/controller/ContractController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupSaveImage;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.ContractImage;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.entity.vo.ContractPageableVo;
+import com.example.personnelmanager.service.ContractImageService;
+import com.example.personnelmanager.service.ContractService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.util.ClassUtils;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.UUID;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ContractController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/15
+ **/
+@RestController
+@RequestMapping("/api/contract")
+public class ContractController {
+
+    @Autowired
+    ContractService contractService;
+
+    @Autowired
+    ContractImageService contractImageService;
+
+    @RequestMapping(method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<Contract> addContract(@Validated(GroupSave.class) @RequestBody Contract contract) {
+        Contract addContract = contractService.addEntity(contract);
+        ResultObj<Contract> resultObj = new ResultObj(addContract, addContract != null ? "success" : "插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/list", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj getContractPage(@RequestBody ContractPageableVo contractVo) {
+        return new ResultObj(contractService.getList(contractVo.getContract(), contractVo.getPageable()), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delContract(@Validated(GroupDelete.class) @RequestBody Contract contract) {
+        return new ResultObj(contractService.delete(contract.getContractId()), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getContract(@Validated(GroupDelete.class) Contract contract) {
+        return new ResultObj(contractService.getOne(contract.getContractId()), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updateContract(@Validated(GroupUpdate.class) @RequestBody Contract contract) {
+        return new ResultObj(contractService.update(contract), "success");
+    }
+
+    @RequestMapping(value = "/file",method = RequestMethod.POST)
+    public ContractImage addContractImage(@RequestParam("file") MultipartFile file,@Validated(GroupSaveImage.class) Long contractId) throws IOException {
+        if (!file.isEmpty()) {
+            ContractImage contractImage = new ContractImage();
+            //获取文件名
+            String fileName = file.getOriginalFilename();
+            //获取文件后缀
+            String suffixName = fileName.substring(fileName.lastIndexOf("."));
+            //重新生成文件名
+            fileName = UUID.randomUUID() + suffixName;
+            //指定本地存入路径
+            String path = ClassUtils.getDefaultClassLoader().getResource("static/images/").getPath();
+            file.transferTo(new File(path + fileName));
+            Contract contract = new Contract();
+            contract.setContractId(contractId);
+            contractImage.setContract(contract);
+            contractImage.setUrl("/images/" + fileName);
+            contractImageService.addEntity(contractImage);
+        } else {
+            throw new GlobalException("文件是空的");
+        }
+        return null;
+    }
+
+}

src/main/java/com/example/personnelmanager/controller/EducationalExperienceController.java

+package com.example.personnelmanager.controller;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class EducationalExperienceController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/20
+ **/
+
+@RestController
+@RequestMapping("/api/educationalExperience")
+public class EducationalExperienceController {
+
+}

src/main/java/com/example/personnelmanager/controller/LegalEntityController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.entity.vo.LegalEntityPageableVo;
+import com.example.personnelmanager.service.LegalEntityService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntity
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/13
+ **/
+
+@RestController
+@RequestMapping("/api/legalEntity")
+public class LegalEntityController {
+
+    @Autowired
+    LegalEntityService legalEntityService;
+
+    @RequestMapping(method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<LegalEntity> addLegalEntity(@Validated(GroupSave.class) @RequestBody LegalEntity legalEntity){
+        LegalEntity addLegal = legalEntityService.addEntity(legalEntity);
+        ResultObj<LegalEntity> resultObj = new ResultObj(addLegal,addLegal!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/list",produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj getLegalEntityPage(@RequestBody LegalEntityPageableVo legalEntityPageableVo){
+        return new ResultObj(legalEntityService.getList(legalEntityPageableVo.getLegalEntity(), legalEntityPageableVo.getPageable()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delLegalEntity(@Validated(GroupDelete.class) @RequestBody LegalEntity legalEntity){
+        return new ResultObj(legalEntityService.delete(legalEntity.getLegalEntityId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getLegalEntity(@Validated(GroupDelete.class) LegalEntity legalEntity){
+        return new ResultObj(legalEntityService.getOne(legalEntity.getLegalEntityId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updateLegalEntity(@Validated(GroupUpdate.class) @RequestBody LegalEntity legalEntity){
+        return new ResultObj(legalEntityService.update(legalEntity),"success");
+    }
+}

src/main/java/com/example/personnelmanager/controller/OrganizationNodeController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.OrganizationNode;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.entity.vo.OrganizationNodeListVo;
+import com.example.personnelmanager.service.OrganizationNodeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class OrganizationNodeController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/15
+ **/
+@RestController
+@RequestMapping(value = "/api/organizationNode")
+public class OrganizationNodeController {
+
+    @Autowired
+    OrganizationNodeService organizationNodeService;
+
+    @RequestMapping(method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<OrganizationNode> addOrganizationNode(@Validated(GroupSave.class) @RequestBody OrganizationNode organizationNode){
+        OrganizationNode addNode = organizationNodeService.addEntity(organizationNode);
+        ResultObj<OrganizationNode> resultObj = new ResultObj(addNode,addNode!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/getTree",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<List<OrganizationNodeListVo>> getOrganizationNodeTree(){
+        List<OrganizationNodeListVo> addNode = organizationNodeService.getTree();
+        ResultObj<List<OrganizationNodeListVo>> resultObj = new ResultObj(addNode,addNode!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getOrganizationNode(@Validated(GroupDelete.class) Long nodeId){
+        return new ResultObj(organizationNodeService.getOne(nodeId),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delOrganizationNode(@Validated(GroupDelete.class) @RequestBody Long nodeId) {
+        return new ResultObj(organizationNodeService.delete(nodeId), "success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT, produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updateOrganizationNode(@Validated(GroupUpdate.class) @RequestBody OrganizationNode organizationNode) {
+        return new ResultObj(organizationNodeService.update(organizationNode), "success");
+    }
+}

src/main/java/com/example/personnelmanager/controller/PeopleController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.People;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.entity.vo.PeoplePageableVo;
+import com.example.personnelmanager.service.PeopleService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class PeopleController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/15
+ **/
+@RestController
+@RequestMapping("/api/people")
+public class PeopleController {
+
+    @Autowired
+    PeopleService peopleService;
+
+    @RequestMapping(method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<People> addPeople(@Validated(GroupSave.class) @RequestBody People people){
+        People addPeople = peopleService.addEntity(people);
+        ResultObj<People> resultObj = new ResultObj(addPeople,addPeople!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/list",produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj getPeoplePage(@RequestBody PeoplePageableVo peoplePageableVo){
+        return new ResultObj(peopleService.getList(peoplePageableVo.getPeople(), peoplePageableVo.getPageable()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delPeople(@Validated(GroupDelete.class) @RequestBody People people){
+        return new ResultObj(peopleService.delete(people.getPeopleId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getPeople(@Validated(GroupDelete.class) People people){
+        return new ResultObj(peopleService.getOne(people.getPeopleId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updatePeople(@Validated(GroupUpdate.class) @RequestBody People people){
+        return new ResultObj(peopleService.update(people),"success");
+    }
+
+
+}

src/main/java/com/example/personnelmanager/controller/PostController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.Post;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.entity.vo.PostPageableVo;
+import com.example.personnelmanager.service.PostService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class PostController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/19
+ **/
+@RestController
+@RequestMapping("/api/post")
+public class PostController {
+
+    @Autowired
+    PostService postService;
+
+    @RequestMapping(method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<Post> addPost(@Validated(GroupSave.class) @RequestBody Post post){
+        Post addPost = postService.addEntity(post);
+        ResultObj<Post> resultObj = new ResultObj(addPost,addPost!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/list",produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj getPostPage(@RequestBody PostPageableVo postPageableVo){
+        return new ResultObj(postService.getList(postPageableVo.getPost(),postPageableVo.getPageable()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delPost(@Validated(GroupDelete.class) @RequestBody Post post){
+        return new ResultObj(postService.delete(post.getPostId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getPost(@Validated(GroupDelete.class) Post post){
+        return new ResultObj(postService.getOne(post.getPostId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updatePost(@Validated(GroupUpdate.class) @RequestBody Post post){
+        return new ResultObj(postService.update(post),"success");
+    }
+
+
+}

src/main/java/com/example/personnelmanager/controller/TitleController.java

+package com.example.personnelmanager.controller;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class TitleController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/18
+ **/
+
+@RestController
+@RequestMapping("/api/title")
+public class TitleController {
+}

src/main/java/com/example/personnelmanager/controller/UserController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.User;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.service.UserServer;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class UserController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/14
+ **/
+@RestController
+@RequestMapping("/api/user")
+public class UserController {
+
+    @Autowired
+    UserServer userServer;
+
+    @RequestMapping(method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+        public ResultObj<LegalEntity> addUser(@Validated(GroupSave.class) @RequestBody User user){
+        User addUser = userServer.addEntity(user);
+        ResultObj<LegalEntity> resultObj = new ResultObj(addUser,addUser!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+}

src/main/java/com/example/personnelmanager/controller/WorkPlaceController.java

+package com.example.personnelmanager.controller;
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.WorkPlace;
+import com.example.personnelmanager.entity.commnEntity.ResultObj;
+import com.example.personnelmanager.entity.dto.WorkPlaceDto;
+import com.example.personnelmanager.entity.vo.WorkPlacePageableVo;
+import com.example.personnelmanager.service.WorkPlaceService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class WorkPlaceController
+ * @packageName com.example.personnelmanager.controller
+ * @data 2020/5/14
+ **/
+@RestController
+@RequestMapping("/api/workPlace")
+public class WorkPlaceController {
+
+    @Autowired
+    WorkPlaceService workPlaceService;
+
+    @RequestMapping(method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj<LegalEntity> addLWorkPlace(@Validated(GroupSave.class) @RequestBody WorkPlaceDto workPlaceDto){
+        WorkPlace workPlace = new WorkPlace();
+        BeanUtils.copyProperties(workPlaceDto,workPlace);
+        WorkPlace addWork = workPlaceService.addEntity(workPlace);
+        ResultObj<LegalEntity> resultObj = new ResultObj(addWork,addWork!=null?"success":"插入失败，出现未知的失败原因");
+        return resultObj;
+    }
+
+    @RequestMapping(value = "/list",produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj getWorkPlacePage(@RequestBody WorkPlacePageableVo workPlaceVo){
+        return new ResultObj(workPlaceService.getList(workPlaceVo.getWorkPlace(),workPlaceVo.getPageable()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.DELETE,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj delWorkPlace(@Validated(GroupDelete.class) @RequestBody WorkPlace workPlace){
+        return new ResultObj(workPlaceService.delete(workPlace.getWorkPlaceId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public ResultObj getWorkPlace(@Validated(GroupDelete.class) WorkPlace workPlace){
+        return new ResultObj(workPlaceService.getOne(workPlace.getWorkPlaceId()),"success");
+    }
+
+    @RequestMapping(method = RequestMethod.PUT,produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResultObj updateWorkPlace(@Validated(GroupUpdate.class) @RequestBody WorkPlaceDto workPlaceDto){
+        WorkPlace workPlace = new WorkPlace();
+        BeanUtils.copyProperties(workPlaceDto,workPlace);
+        return new ResultObj(workPlaceService.update(workPlace),"success");
+    }
+}

src/main/java/com/example/personnelmanager/dao/CertificateImageRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.CertificateImage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+public interface CertificateImageRepository extends JpaRepository<CertificateImage, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/dao/CertificateRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.ContractImage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+public interface CertificateRepository extends JpaRepository<Certificate, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/dao/ContractImageRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.ContractImage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ContractRepository
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/15
+ **/
+public interface ContractImageRepository extends JpaRepository<ContractImage, Long>, JpaSpecificationExecutor {
+
+}

src/main/java/com/example/personnelmanager/dao/ContractRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.Post;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ContractRepository
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/15
+ **/
+public interface ContractRepository extends JpaRepository<Contract, Long>, JpaSpecificationExecutor {
+
+}

src/main/java/com/example/personnelmanager/dao/EducationalExperienceRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.EducationalExperience;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class EducationalExperienceRepository
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/20
+ **/
+public interface EducationalExperienceRepository extends JpaRepository<EducationalExperience, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/dao/LegalEntityRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityDao
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/13
+ **/
+public interface LegalEntityRepository extends JpaRepository<LegalEntity, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/dao/OrganizationNodeRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.OrganizationNode;
+import com.example.personnelmanager.entity.vo.OrganizationNodeListVo;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+
+import java.util.List;
+
+public interface OrganizationNodeRepository extends JpaRepository<OrganizationNode, Long>, JpaSpecificationExecutor {
+
+    @Query("select new com.example.personnelmanager.entity.vo.OrganizationNodeListVo(m.nodeId,m.nodeName,m.parentNode,m.nodeType) " +
+            "FROM OrganizationNode m  where m.enterprise.enterpriseId=:enterpriseId and m.deleteTag = 0")
+    List<OrganizationNodeListVo> findTreeNode(Long enterpriseId);
+
+    @Modifying
+    @Query("update OrganizationNode o set o.deleteTag = 1 where o.nodeId=:nodeId or o.nodeLevel like concat('%.',:nodeId,'.%') ")
+    void deleteorganizationNode(Long nodeId);
+
+}

src/main/java/com/example/personnelmanager/dao/PeopleRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.People;
+import com.example.personnelmanager.entity.Post;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+import java.util.List;
+
+public interface PeopleRepository extends JpaRepository<People, Long>, JpaSpecificationExecutor {
+    List<People> findByPhoneAndEnterprise(String phone,Long enterpriseId);
+}

src/main/java/com/example/personnelmanager/dao/PostRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Post;
+import com.example.personnelmanager.entity.vo.PostVo;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+
+import java.util.List;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityDao
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/13
+ **/
+public interface PostRepository extends JpaRepository<Post, Long>, JpaSpecificationExecutor {
+
+    @Query("select new com.example.personnelmanager.entity.vo.PostVo(p.postId,p.postName,p.postIntroduction,p.organizationNode.nodeId) from " +
+            "Post p where p.enterprise.enterpriseId =:enterpriseId and p.deleteTag=0")
+    List<PostVo> findPostListVoByEnterpriseId(Long enterpriseId);
+
+    @Modifying
+    @Query("update Post o set o.deleteTag = 1 where o.organizationNode.nodeId=:nodeId or o.nodeLevel like concat('%.',:nodeId,'.%') ")
+    void deletePostByNodeId(Long nodeId);
+}

src/main/java/com/example/personnelmanager/dao/SimpleJpaRepositoryImpl.java

+package com.example.personnelmanager.dao;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.BeanWrapper;
+import org.springframework.beans.BeanWrapperImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.jpa.repository.support.JpaEntityInformation;
+import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import javax.persistence.EntityManager;
+import java.beans.PropertyDescriptor;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class SimpleJpaRepositoryImpl
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/14
+ **/
+public class SimpleJpaRepositoryImpl<T, ID> extends SimpleJpaRepository<T, ID> {
+
+    private final JpaEntityInformation<T, ?> entityInformation;
+    private final EntityManager em;
+
+    @Autowired
+    public SimpleJpaRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
+        super(entityInformation, entityManager);
+        this.entityInformation = entityInformation;
+        this.em = entityManager;
+    }
+
+    public SimpleJpaRepositoryImpl(Class<T> domainClass, EntityManager em, JpaEntityInformation<T, ?> entityInformation, EntityManager em1) {
+        super(domainClass, em);
+        this.entityInformation = entityInformation;
+        this.em = em1;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public <S extends T> S save(S entity) {
+        //获取ID
+        ID entityId = (ID) entityInformation.getId(entity);
+        Optional<T> optionalT ;
+        if (StringUtils.isEmpty(entityId)) {
+            optionalT = Optional.empty();
+        } else {
+            //若ID非空 则查询最新数据
+            optionalT = findById(entityId);
+        }
+        //获取空属性并处理成null
+        String[] nullProperties = getNullProperties(entity);
+        //若根据ID查询结果为空
+        if (!optionalT.isPresent()) {
+            //新增
+            em.persist(entity);
+            return entity;
+        } else {
+            //1.获取最新对象
+            T target = optionalT.get();
+            //2.将非空属性覆盖到最新对象
+            BeanUtils.copyProperties(entity, target, nullProperties);
+            //3.更新非空属性
+            em.merge(target);
+            return entity;
+        }
+    }
+    private static String[] getNullProperties(Object src) {
+        //1.获取Bean
+        BeanWrapper srcBean = new BeanWrapperImpl(src);
+        //2.获取Bean的属性描述
+        PropertyDescriptor[] pds = srcBean.getPropertyDescriptors();
+        //3.获取Bean的空属性
+        Set<String> properties = new HashSet<>();
+        for (PropertyDescriptor propertyDescriptor : pds) {
+            String propertyName = propertyDescriptor.getName();
+            Object propertyValue = srcBean.getPropertyValue(propertyName);
+            if (StringUtils.isEmpty(propertyValue)) {
+                srcBean.setPropertyValue(propertyName, null);
+                properties.add(propertyName);
+            }
+        }
+        return properties.toArray(new String[0]);
+    }
+}

src/main/java/com/example/personnelmanager/dao/TitleImageRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.TitleImage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+public interface TitleImageRepository extends JpaRepository<TitleImage, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/dao/TitleRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.Title;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+public interface TitleRepository extends JpaRepository<Title, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/dao/UserRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityDao
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/13
+ **/
+public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor {
+
+    User findByUsername(String username);
+}

src/main/java/com/example/personnelmanager/dao/WorkPlaceRepository.java

+package com.example.personnelmanager.dao;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.WorkPlace;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityDao
+ * @packageName com.example.personnelmanager.dao
+ * @data 2020/5/13
+ **/
+public interface WorkPlaceRepository extends JpaRepository<WorkPlace, Long>, JpaSpecificationExecutor {
+}

src/main/java/com/example/personnelmanager/entity/Certificate.java

+package com.example.personnelmanager.entity;
+
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "certificate")
+@ToString(exclude = {"people","enterprise"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class Certificate {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "certificate_id"  ,columnDefinition = "bigint comment '合同编号'")
+  private long certificateId;
+
+  @Column(name = "certificate_name" ,columnDefinition = "varchar(64) comment '证书名称'")
+  private String certificateName;
+
+  @Column(name = "certificate_obtain_time" , columnDefinition = "datetime comment '证书获得时间'")
+  private Instant certificateObtainTime;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间' ")
+  private Instant createTime;
+
+  @Column(name = "licensing_organization",columnDefinition = "varchar(64) comment '发证机关'")
+  private String licensingOrganization;
+
+  @OneToMany(cascade = CascadeType.REFRESH,mappedBy = "certificate")
+  List<CertificateImage> certificateImages;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "people_id",columnDefinition = "bigint not null comment '人员编号'")
+  private People people;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+}

src/main/java/com/example/personnelmanager/entity/CertificateImage.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "certificate_image")
+@ToString(exclude = "certificate")
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class CertificateImage {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "certificate_image_id" , columnDefinition = "bigint comment '证书图片编号'")
+  private long certificateImageId;
+
+  @Lob
+  @Column(name = "url",columnDefinition="text comment '地址'")
+  private String url;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createTime;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "certificate_id",nullable = false,columnDefinition = "bigint comment '证书编号'")
+  private Certificate certificate;
+}

src/main/java/com/example/personnelmanager/entity/Contract.java

+package com.example.personnelmanager.entity;
+
+import com.example.personnelmanager.common.validIGroup.*;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "contract")
+@ToString(exclude = {"people","enterprise"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class Contract {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "contract_id" ,columnDefinition = "bigint comment '合同编号' ")
+  @Min(value = 0,groups = {GroupSaveImage.class, GroupUpdate.class, GroupGetOne.class, GroupDelete.class},message = "此操作需要只能一个对象")
+  private long contractId;
+
+  @Column(name = "contract_company" , columnDefinition = "varchar(128) comment '合同公司' ")
+  private String contractCompany;
+
+  @Column(name = "contract_type" , columnDefinition = "varchar(16) comment '合同类型(劳务合同、劳动合同、实习合同、雇佣合同、其他)'")
+  private String contractType;
+
+  @NotNull(message = "合同开始时间不能为空",groups = {GroupSave.class})
+  @Column(name = "contract_start_time" , columnDefinition = " datetime comment '合同开始时间' ")
+  private Instant contractStartTime;
+
+  @NotNull(message = "合同结束时间不能为空",groups = {GroupSave.class})
+  @Column(name = "contract_end_time" , columnDefinition = " datetime comment '合同结束时间' ")
+  private Instant contractEndTime;
+
+  @Column(name = "contract_sign_time" , columnDefinition = " datetime comment '合同签订时间'")
+  private Instant contractSignTime;
+
+  @Lob
+  @Column(name = "remark", columnDefinition = "text comment '备注'")
+  private String remark;
+
+
+  @Column(name = "delete_tag" ,nullable = false, columnDefinition = "int default 0 comment '删除标记'")
+  private int deleteTag;
+
+  @Column(name = "create_time" ,nullable = false, columnDefinition = "datetime default CURRENT_TIMESTAMP comment '删除标记（0为正常，1为被删除）'")
+  private Instant createTime;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "contract")
+  private List<ContractImage> contractImages;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "people_id",columnDefinition = "bigint not null comment '人员编号'")
+  private People people;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+}

src/main/java/com/example/personnelmanager/entity/ContractImage.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "contract_image")
+@ToString(exclude = {"contract"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class ContractImage {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "contract_image_id",columnDefinition = "bigint comment '合同照片编号' ")
+  private long contractImageId;
+
+  @Lob
+  @Column(name = "url",columnDefinition = "text comment '照片地址'")
+  private String url;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）' ")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间' ")
+  private Instant createTime;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "contract_id",nullable = false,columnDefinition = "bigint comment '合同编号'")
+  private Contract contract;
+}

src/main/java/com/example/personnelmanager/entity/EducationImage.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "education_image")
+@ToString(exclude = {"educationalExperience"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class EducationImage {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "educational_image_id",columnDefinition = "bigint comment '教育经历照片编号' ")
+  private long educationalImageId;
+
+  @Lob
+  @Column(name = "url",columnDefinition = " text comment '教育经历照片地址'")
+  private String url;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = " int default 0 comment '删除标记（0为正常，1为被删除）' ")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = " datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "educational_id",nullable = false,columnDefinition = "bigint comment '教育经历编号'")
+  private EducationalExperience educationalExperience;
+
+}

src/main/java/com/example/personnelmanager/entity/EducationalExperience.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "educational_experience")
+@ToString(exclude = {"people","enterprise"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class EducationalExperience {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "educational_id",columnDefinition = "bigint comment '合同照片编号' ")
+  private long educationalId;
+
+  @Column(name = "qualifications",nullable = false,columnDefinition = "varchar(16) comment '学历(初中、高中、大专/高职、本科、硕士/MBA/EMBA、博士、其他)'")
+  private String qualifications;
+
+  @Column(name = "Graduation_school", columnDefinition = "varchar(128) comment '毕业院校' ")
+  private String graduationSchool;
+
+  @Column(name = "Graduation_date",columnDefinition = " datetime comment '毕业时间' ")
+  private Instant graduationDate;
+
+  @Column(name = "major",columnDefinition = "varchar(64) comment '所学专业'")
+  private String major;
+
+  @Column(name = "has_degree",columnDefinition = "bool comment '是否取得学位'")
+  private Boolean hasDegree;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createTime;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "educationalExperience")
+  private List<EducationImage> educationImages;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "people_id",columnDefinition = "bigint not null comment '人员编号'")
+  private People people;
+
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+}

src/main/java/com/example/personnelmanager/entity/Enterprise.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "enterprise")
+@ToString(exclude = {"peoples","posts","workPlaces","organizationNodes","certificates","legalEntities","contracts","duties","educationalExperiences","titles","users"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class Enterprise implements Serializable {
+
+  private static final long serialVersionUID = 1107313482047123539L;
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "enterprise_id",columnDefinition = "bigint comment '企业编号' ")
+  private long enterpriseId;
+
+  @Column(name = "enterprise_name",nullable = false,columnDefinition = "varchar(128) comment '企业名称'")
+  private String enterpriseName;
+
+  @Column(name = "enterprise_profession",columnDefinition = "varchar(64) comment '所属行业'")
+  private String enterpriseProfession;
+
+  @Column(name = "enterprise_province",columnDefinition = "varchar(16) comment '所在省份'")
+  private String enterpriseProvince;
+
+  @Column(name = "contact_name",columnDefinition = "varchar(64) comment '联系人姓名'")
+  private String contactName;
+
+  @Column(name = "contact_phone",columnDefinition = "varchar(16) comment '联系人电话'")
+  private String contactPhone;
+
+  @Column(name = "contact_mail",columnDefinition = "varchar(255) comment '联系人邮箱'")
+  private String contactMail;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = " datetime default CURRENT_TIMESTAMP comment '删除标记（0为正常，1为被删除）'")
+  private Instant createTime;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<People> peoples;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<Post> posts;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<WorkPlace> workPlaces;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<OrganizationNode> organizationNodes;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<Certificate> certificates;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<LegalEntity> legalEntities;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<Contract> contracts;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<EducationalExperience> educationalExperiences;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<Title> titles;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL,mappedBy = "enterprise")
+  private List<User> users;
+
+}

src/main/java/com/example/personnelmanager/entity/JobTransferInformation.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "job_transfer_information")
+@ToString(exclude = {"people"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class JobTransferInformation {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "transfer_id",columnDefinition = "bigint comment '调岗记录编号' ")
+  private long transferId;
+
+  @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH)
+  @JoinColumn(name = "before_Post_id",columnDefinition = "bigint comment '换岗前岗位编号' ")
+  private Post beforePost;
+
+  @OneToOne(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH)
+  @JoinColumn(name = "after_Post_id",columnDefinition = "bigint comment '换岗后岗位编号' ")
+  private Post afterPost;
+
+  @Lob
+  @Column(name = "transfer_information",columnDefinition = "text comment '备注' ")
+  private String transferInformation;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = " datetime default CURRENT_TIMESTAMP comment '删除标记（0为正常，1为被删除）'")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "people_id",columnDefinition = "bigint comment '所属人员'")
+  private People people;
+
+}

src/main/java/com/example/personnelmanager/entity/LeaveInformation.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "leave_information")
+@ToString(exclude = {"people"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class LeaveInformation {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "enterprise_id",columnDefinition = "bigint comment '企业编号' ")
+  private long leaveId;
+
+  @Column(name = "leave_type",columnDefinition = "varchar(16) comment '离职类型(主动离职，被动离职，其他)' ")
+  private String leaveType;
+
+  @Column(name = "leave_time",nullable = false,columnDefinition = "datetime comment '离职时间' ")
+  private Instant leaveTime;
+
+  @Lob
+  @Column(name = "leave_reason",nullable = false,columnDefinition = "text comment '离职原因' ")
+  private String leaveReason;
+
+  @Column(name = "last_work_time",columnDefinition = "datetime comment '最后工作日期' ")
+  private Instant lastWorkTime;
+
+  @Column(name = "pay_time",columnDefinition = "datetime comment '薪酬结算日期' ")
+  private Instant payTime;
+
+  @Lob
+  @Column(name = "remark",columnDefinition = "text comment '备注' ")
+  private String remark;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = " datetime default CURRENT_TIMESTAMP comment '删除标记（0为正常，1为被删除）'")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "people_id",columnDefinition = "bigint comment '所属人员'")
+  private People people;
+
+
+}

src/main/java/com/example/personnelmanager/entity/LegalEntity.java

+package com.example.personnelmanager.entity;
+
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupGetOne;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Null;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "legal_entity")
+@ToString(exclude = {"enterprise","organizationNodes","organizationNodes"})
+public class LegalEntity {
+
+  @Max(value = 0,groups = {GroupSave.class} )
+  @NotNull(groups = {GroupDelete.class, GroupGetOne.class, GroupUpdate.class})
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "legal_entity_id",columnDefinition = "bigint comment '企业编号' ")
+  private long legalEntityId;
+
+  @NotNull(groups = {GroupSave.class,GroupUpdate.class},message = "法律实体名称不能为空")
+  @Column(name = "legal_entity_name",nullable = false,columnDefinition = "varchar(128) comment '法律实体名称' ")
+  private String legalEntityName;
+
+  @NotNull(groups = {GroupSave.class,GroupUpdate.class},message = "社会信用代码不能为空")
+  @Column(name = "social_credit_code",nullable = false,columnDefinition = "varchar(18) comment '社会信用代码' ")
+  private String socialCreditCode;
+
+  @Column(name = "tax_declaration_area",columnDefinition = "varchar(255) comment '报税区域' ")
+  private String taxDeclarationArea;
+
+  @Column(name = "address",columnDefinition = "varchar(255) comment '所在地址' ")
+  private String address;
+
+  @Column(name = "phone",columnDefinition = "varchar(16) comment '电话' ")
+  private String phone;
+
+  @Column(name = "bank",columnDefinition = "varchar(64) comment '开户银行' ")
+  private String bank;
+
+  @Column(name = "bank_number",columnDefinition = "varchar(128) comment '银行账号' ")
+  private String bankNumber;
+
+  @Lob
+  @Column(name = "remark",columnDefinition = "text comment '备注' ")
+  private String remark;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记'")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = " datetime default CURRENT_TIMESTAMP comment '删除标记（0为正常，1为被删除）'")
+  private Instant createTime;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @JsonIgnoreProperties(value = {"legalEntities","titles","educationalExperiences","duties","contracts","legalEntities","certificates","organizationNodes","workPlaces","posts","peoples","users"})
+  @ManyToOne(cascade={CascadeType.REFRESH})
+  @JoinColumn(name = "enterprise_id",nullable = false,columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+  @JsonIgnore
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "legalEntity")
+  private List<OrganizationNode> organizationNodes;
+
+
+}

src/main/java/com/example/personnelmanager/entity/OrganizationNode.java

+package com.example.personnelmanager.entity;
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupGetOne;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "organization_node")
+@ToString(exclude = {"enterprise","posts","duties","legalEntity","legalEntity"})
+public class OrganizationNode {
+
+  @Max(value = 0,groups = {GroupSave.class} )
+  @NotNull(groups = {GroupDelete.class, GroupGetOne.class, GroupUpdate.class})
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "node_id",columnDefinition = "bigint comment '节点编号' ")
+  private long nodeId;
+
+  @NotNull(groups = {GroupSave.class},message = "节点名称不能为空")
+  @Column(name = "node_name",nullable = false,columnDefinition = "varchar(64) comment '节点名称' ")
+  private String nodeName;
+
+  @Min(value = 0,groups = {GroupUpdate.class})
+  @NotNull(groups = {GroupSave.class},message = "上级节点不能为空")
+  @Column(name = "parent_node",columnDefinition = "bigint comment '上级节点' ")
+  private long parentNode;
+
+  @NotNull(groups = {GroupSave.class},message = "节点类型不能为空")
+  @Column(name = "node_type",columnDefinition = "varchar(32) comment '节点类型' ")
+  private String nodeType;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = " datetime default CURRENT_TIMESTAMP comment '删除标记（0为正常，1为被删除）'")
+  private Instant createTime;
+
+  @Lob
+  @Column(name = "node_profile",columnDefinition = "text comment '节点简介' ")
+  private String nodeProfile;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记'")
+  private int deleteTag;
+
+  @Lob
+  @Column(name = "node_level",nullable = false,columnDefinition = "text comment '节点等级 例如0.1.4.5 这些数字代表的节点的父节点之间的关系'")
+  private String nodeLevel;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+  @ManyToOne(cascade={CascadeType.REFRESH})
+  @JoinColumn(name = "legal_entity_id",columnDefinition = "bigint comment '法律实体编号'")
+  private LegalEntity legalEntity;
+
+  @ManyToOne(cascade={CascadeType.REFRESH})
+  @JoinColumn(name = "work_place_id",columnDefinition = "bigint comment '工作地点编号'")
+  private WorkPlace workPlace;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(cascade = CascadeType.REFRESH,mappedBy = "organizationNode")
+  private List<Post> posts;
+
+  @Transient
+  private List<OrganizationNode> childeNodes;
+
+}

src/main/java/com/example/personnelmanager/entity/People.java

+package com.example.personnelmanager.entity;
+
+
+import com.example.personnelmanager.common.validIGroup.GroupDelete;
+import com.example.personnelmanager.common.validIGroup.GroupGetOne;
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.swagger.models.auth.In;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.NotNull;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "people")
+@ToString(exclude = {"enterprise"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class People {
+
+  @Id
+  @NotNull(groups = {GroupDelete.class, GroupGetOne.class, GroupUpdate.class})
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "people_id")
+  private long peopleId;
+
+  @NotNull(groups = {GroupSave.class})
+  @Column(name = "name",nullable = false,columnDefinition = "varchar(16) comment '所属企业'")
+  private String name;
+
+  @Column(name = "sex",columnDefinition = "varchar(8) comment '性别'")
+  private String sex;
+
+  @Column(name = "age",columnDefinition = "int comment '年龄'")
+  private int age;
+
+  @NotNull(groups = {GroupSave.class})
+  @Column(name = "phone",nullable = false,columnDefinition = "varchar(16) comment '手机号码'")
+  private String phone;
+
+  @Column(name = "working_number",columnDefinition = "varchar(16) comment '工号'")
+  private String workingNumber;
+
+  @Column(name = "working_age",columnDefinition = "decimal(8,1) comment '工龄'")
+  private double workingAge;
+
+  @Column(name = "history_working_age",columnDefinition = "decimal(8,1) comment '历史工龄'")
+  private double historyWorkingAge;
+
+  @Column(name = "politic_countenance",columnDefinition = "varchar(16) comment '政治面貌'")
+  private String politicCountenance;
+
+  @Column(name = "birthday",columnDefinition = "datetime comment '出生日期'")
+  private Instant birthday;
+
+  @Column(name = "native_place",columnDefinition = "varchar(32) comment '籍贯'")
+  private String nativePlace;
+
+  @Column(name = "id_card_type",columnDefinition = "varchar(8) comment '身份证件类型（身份证、护照、居留'")
+  private String idCardType;
+
+  @Column(name = "id_card_number",columnDefinition = "varchar(32) comment '身份证件号码'")
+  private String idCardNumber;
+
+  @Column(name = "id_card_address",columnDefinition = "varchar(32) comment '身份证件号码'")
+  private String idCardAddress;
+
+  @Lob
+  @Column(name = "id_card_front_url",columnDefinition = "text comment '证件正面照'")
+  private String idCardFrontUrl;
+
+  @Lob
+  @Column(name = "id_card_back_url",columnDefinition = "text comment '证件背面照'")
+  private String idCardBackUrl;
+
+  @Column(name = "id_card_is_long_validity",columnDefinition = "bool default false comment '证件是否长期有效'")
+  private boolean idCardIsLongValidity;
+
+  @Column(name = "id_card_validity_date",columnDefinition = "datetime comment '证件有效期'")
+  private Instant idCardValidityDate;
+
+  @Column(name = "marital_status",columnDefinition = "varchar(8) comment '婚姻状况(已婚、未婚)'")
+  private String maritalStatus;
+
+  @Column(name = "census_register_type",columnDefinition = "varchar(8) comment '户籍类型(农业、非农)'")
+  private String censusRegisterType;
+
+  @Column(name = "social_security_account",columnDefinition = "varchar(255) comment '个人社保账号'")
+  private String socialSecurityAccount;
+
+  @Column(name = "accumulation_fund_account",columnDefinition = "varchar(255) comment '个人公积金账号'")
+  private String accumulationFundAccount;
+
+  @Column(name = "paycard_number",columnDefinition = "varchar(255) comment '工资卡卡号'")
+  private String paycardNumber;
+
+  @Column(name = "paycard_bank",columnDefinition = "varchar(32) comment '工资卡开户行'")
+  private String paycardBank;
+
+  @Column(name = "job_status",columnDefinition = "varchar(8) comment '在职状态具有以下几种：在职、离职、待入职、实习、试用、退休。其中实习、试用由用户填写的试用结束时间和实习结束时间决定，若用户填写实习结束时间并且时间晚于当前时间则人员处于实习状态，若用户填写试用结束时间并且时间晚于当前时间则人员处于试用状态。其余状态由用户手动变更'")
+  private String jobStatus;
+
+  @Column(name = "highest_education",columnDefinition = "varchar(16) comment '最高学历(初中、高中、大专/高职、本科、硕士/MBA/EMBA、博士、其他)'")
+  private String highestEducation;
+
+  @Column(name = "qq_number",columnDefinition = "varchar(64) comment 'QQ号码'")
+  private String qqNumber;
+
+  @Column(name = "wechat_number",columnDefinition = "varchar(255) comment '微信号码'")
+  private String wechatNumber;
+
+  @Column(name = "mail",columnDefinition = "varchar(255) comment '个人邮箱'")
+  private String mail;
+
+  @Column(name = "current_residence",columnDefinition = "varchar(255) comment '现居住地'")
+  private String currentResidence;
+
+  @NotNull(groups = {GroupSave.class})
+  @Column(name = "entry_time",nullable = false,columnDefinition = "datetime comment '入职时间'")
+  private Instant entryTime;
+
+  @Column(name = "internship_end_time",columnDefinition = "datetime comment '实习结束时间'")
+  private Instant internshipEndTime;
+
+  @Column(name = "trial_end_time",columnDefinition = "datetime comment '试用结束时间'")
+  private Date trialEndTime;
+
+  @Column(name = "deleteTag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）' ")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间' ")
+  private Instant createTime;
+
+  @Max(value = 0,message = "所属企业不允许被修改",groups = {GroupUpdate.class})
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<Certificate> certificates ;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<Contract> contracts;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<EducationalExperience> educationalExperiences;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<Urgent> urgents;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<Title> titles;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<JobTransferInformation> jobTransferInformations;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<LeaveInformation> leaveInformations;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "people")
+  private List<WorkExperience> workExperiences;
+
+}

src/main/java/com/example/personnelmanager/entity/PeoplePost.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class PeoplePost
+ * @packageName com.example.personnelmanager.entity
+ * @data 2020/5/14
+ **/
+@Entity
+@DynamicUpdate
+@DynamicInsert
+@Table(name = "people_post")
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class PeoplePost implements Serializable {
+
+    private static final long serialVersionUID = 1207408282047173539L;
+
+    @Id
+    @ManyToOne()
+    @JoinColumn(name="people_id")
+    private People people;
+
+    @Id
+    @ManyToOne()
+    @JoinColumn(name="post_id")
+    private Post post;
+}

src/main/java/com/example/personnelmanager/entity/Post.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@ToString(exclude = {"organizationNode","enterprise","duty"})
+@Table(name = "post")
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class Post {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "post_id",columnDefinition = "bigint comment '岗位编号' ")
+  private long postId;
+
+  @Column(name = "post_name",nullable = false,columnDefinition = "varchar(64) comment '岗位名称' ")
+  private String postName;
+
+  @Column(name = "post_type",columnDefinition = "varchar(32) comment '岗位类别' ")
+  private String postType;
+
+  @Lob
+  @Column(name = "node_level",nullable = false,columnDefinition = "text comment '所属节点等级 例如0.1.4.5 具体解释请参考组织节点表，本属性与组织节点表同步，在此处添加该属性主要目的是为了增加查询'")
+  private String nodeLevel;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间' ")
+  private Instant createTime;
+
+  @Lob
+  @Column(name = "post_introduction",columnDefinition = "text comment '岗位简介' ")
+  private String postIntroduction;
+
+  @Column(name = "deleteTag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）' ")
+  private int deleteTag;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+  @ManyToOne(cascade={CascadeType.REFRESH})
+  @JoinColumn(name = "node_id",columnDefinition = "bigint comment '所属节点'")
+  private OrganizationNode organizationNode;
+
+  @Transient
+  private List<People> peoples;
+
+}

src/main/java/com/example/personnelmanager/entity/Title.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "title")
+@ToString(exclude = {"people","enterprise"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class Title {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "title_id",columnDefinition = "bigint comment '职称编号'")
+  private long titleId;
+
+  @Column(name = "title_level",nullable = false,columnDefinition = "varchar(16) comment '职称等级具有以下几种：员级、助理级、中级、副高级、正高'")
+  private String titleLevel;
+
+  @Column(name = "title_type",columnDefinition = "varchar(32) comment '职称类型具有以下几种：高等学校教师、中等专业学校教师、技工学校教师、中学教师、小学教师、幼儿园教师、自然科学研究人员、社会科学研究人员、工程技术人员、实验技术人员、农业技术人员、卫生技术人员、经济专业人员、会计专业人员、审计专业人员、统计专业人员、新闻专业人员、出版专业人员、图书资料专业人员、文物博物专业人员、档案专业人员、广播电视播音人员、翻译人员、律师、公证员、海关人员、船舶技术人员、民用航空飞行技术人员、艺术专业人员、工艺美术专业人员、体育教练员、思想政治工作人员'")
+  private String titleType;
+
+  @Column(name = "title_name",nullable = false,columnDefinition = "varchar(64) comment '职称名称'")
+  private String titleName;
+
+  @Column(name = "title_obtain_date",columnDefinition = "datetime comment '职称证书获得时间'")
+  private Instant titleObtainDate;
+
+  @Column(name = "deleteTag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）' ")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间' ")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "people_id",columnDefinition = "bigint comment '所属人员'")
+  private People people;
+
+  @ManyToOne(fetch = FetchType.LAZY,cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "title")
+  private List<TitleImage> titleImages ;
+
+}

src/main/java/com/example/personnelmanager/entity/TitleContent.java

+//package com.example.personnelmanager.entity;
+//
+//import javax.persistence.*;
+//
+///**
+// * @author HuangXiahao
+// * @version V1.0
+// * @class TitleContent
+// * @packageName com.example.personnelmanager.entity
+// * @data 2020/5/18
+// **/
+//@Entity
+//public class TitleContent {
+//
+//    @Id
+//    @GeneratedValue(strategy = GenerationType.IDENTITY)
+//    @Column(name = "title_content_id",columnDefinition = "bigint comment '职称内容编号'")
+//    private long titleId;
+//
+//    private String titleLevel;
+//
+//    private String titleType;
+//}

src/main/java/com/example/personnelmanager/entity/TitleImage.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "title_image")
+@ToString(exclude = {"title"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class TitleImage {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "title_image_id",columnDefinition = "bigint comment '职称照片' ")
+  private long titleImageId;
+
+  @Lob
+  @Column(name = "url",columnDefinition = "text comment '图片地址' ")
+  private String url;
+
+  @Column(name = "deleteTag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）' ")
+  private int deleteTag;
+
+  @Column(name = "create_time",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间' ")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional = false)
+  @JoinColumn(name = "title_id",nullable = false,columnDefinition = "bigint comment '职称编号'")
+  private Title title;
+}

src/main/java/com/example/personnelmanager/entity/Urgent.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "urgent")
+@ToString(exclude = {"people"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class Urgent {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "urgent_id",columnDefinition = "bigint comment '紧急联系人编号'")
+  private long urgentId;
+
+  @Column(name = "name",columnDefinition = "varchar(8) not null comment '姓名'")
+  private String name;
+
+  @Column(name = "relation",columnDefinition = "varchar(16) comment '关系'")
+  private String relation;
+
+  @Column(name = "phone",columnDefinition = "varchar(16) comment '电话'")
+  private String phone;
+
+  @Column(name = "address",columnDefinition = "varchar(255) comment '住址'")
+  private String address;
+
+  @Column(name = "delete_tag",columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private int deleteTag;
+
+  @Column(name = "create_date",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "people_id",columnDefinition = "bigint comment '所属人员'")
+  private People people;
+
+}

src/main/java/com/example/personnelmanager/entity/User.java

+package com.example.personnelmanager.entity;
+
+
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotNull;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "user")
+@ToString(exclude = {"enterprise"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class User {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "user_id",columnDefinition = "bigint comment '用户编号'")
+  private long userId;
+
+  @Column(name = "username",unique = true,columnDefinition = "varchar(64) comment '用户名' ")
+  private String username;
+
+  @NotNull(groups = {GroupSave.class})
+  @Column(name = "password",nullable = false,columnDefinition = "varchar(255) comment '密码'")
+  private String password;
+
+  @Column(name = "create_date",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createDate;
+
+  @Column(name = "phone",columnDefinition = "varchar(16) comment '手机号码'")
+  private String phone;
+
+  @Column(name = "administrator",columnDefinition = "bool comment '是否超级管理员'")
+  private boolean administrator;
+
+  @Column(name = "delete_tag",columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private int deleteTag;
+
+  @NotNull(groups = {GroupSave.class},message = "无所属企业")
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+
+}

src/main/java/com/example/personnelmanager/entity/UserAndEnterprise.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class User_Enterprise
+ * @packageName com.example.personnelmanager.entity
+ * @data 2020/5/14
+ **/
+
+@Entity
+@DynamicUpdate
+@DynamicInsert
+@Table(name = "user_enterprise")
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class UserAndEnterprise implements Serializable {
+
+    private static final long serialVersionUID = 1207408297047174539L;
+
+    @Id
+    @ManyToOne()
+    @JoinColumn(name="user_id")
+    private User user;
+
+    @Id
+    @ManyToOne()
+    @JoinColumn(name="enterprise_id")
+    private Enterprise enterprise;
+
+
+}

src/main/java/com/example/personnelmanager/entity/UserDetail.java

+package com.example.personnelmanager.entity;
+
+import com.example.personnelmanager.entity.User;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * 描述: 用户类
+ * 继承了SpringSecurity的UserDtails
+ * 用于SpringSecurity框架的用户数据传输
+ *
+ * @author HuangXiahao
+ * @version V1.0
+ * @class UserDetailVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/14
+ **/
+public class UserDetail extends User implements UserDetails {
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        List<GrantedAuthority> simpleGrantedAuthorities = new ArrayList<>();
+        return simpleGrantedAuthorities;
+    }
+
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/entity/WorkExperience.java

+package com.example.personnelmanager.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "work_experience")
+@ToString(exclude = {"people"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class WorkExperience {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "work_experience_id",columnDefinition = "bigint comment '工作经历编号'")
+  private long workExperienceId;
+
+  @Column(name = "post",columnDefinition = "varchar(16) comment '职务'")
+  private String post;
+
+  @Column(name = "work_end_time",nullable = false,columnDefinition = "datetime comment '用户编号'")
+  private Instant workEndTime;
+
+  @Column(name = "work_start_time",nullable = false,columnDefinition = "datetime comment '工作结束时间'")
+  private Instant workStartTime;
+
+  @Column(name = "leave_reason",columnDefinition = "varchar(255) comment '离职原因'")
+  private String leaveReason;
+
+  @Column(name = "witness",columnDefinition = "varchar(8) comment '证明人'")
+  private String witness;
+
+  @Column(name = "witness_phone",columnDefinition = "varchar(16) comment '证明人电话'")
+  private String witnessPhone;
+
+  @Column(name = "delete_tag",nullable = false,columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private long deleteTag;
+
+  @Column(name = "create_date",nullable = false,columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createTime;
+
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "people_id",columnDefinition = "bigint comment '所属人员'")
+  private People people;
+
+
+}

src/main/java/com/example/personnelmanager/entity/WorkPlace.java

+package com.example.personnelmanager.entity;
+
+
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+import sun.security.jgss.GSSCaller;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Null;
+import java.time.Instant;
+import java.util.List;
+
+@Data
+@Entity
+@DynamicInsert
+@DynamicUpdate
+@Table(name = "work_place")
+@ToString(exclude = {"enterprise","organizationNodes"})
+@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler"})
+public class WorkPlace {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @Column(name = "work_place_id",columnDefinition = "bigint comment '工作地点编号'")
+  private long workPlaceId;
+
+  @NotNull(groups = {GroupSave.class, GroupUpdate.class})
+  @Column(name = "work_place_name",nullable = false,columnDefinition = "varchar(64) comment '工作地点名称'")
+  private String workPlaceName;
+
+  @NotNull(groups = {GroupSave.class, GroupUpdate.class})
+  @Column(name = "work_place_area",nullable = false,columnDefinition = "varchar(64) comment '工作地点地区'")
+  private String workPlaceArea;
+
+  @Column(name = "work_place_address",columnDefinition = "varchar(255) comment '详细地址'")
+  private String workPlaceAddress;
+
+  @Column(name = "work_place_type",columnDefinition = "varchar(8) comment '类型'")
+  private String workPlaceType;
+
+  @Lob
+  @Column(name = "work_place_descript",columnDefinition = "text comment '描述'")
+  private String workPlaveDescript;
+
+  @Column(name = "delete_tag",columnDefinition = "int default 0 comment '删除标记（0为正常，1为被删除）'")
+  private long deleteTag;
+
+  @Column(name = "create_time",columnDefinition = "datetime default CURRENT_TIMESTAMP comment '创建时间'")
+  private Instant createTime;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
+  @JoinColumn(name = "enterprise_id",columnDefinition = "bigint comment '所属企业'")
+  private Enterprise enterprise;
+
+  @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+  @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.REFRESH,mappedBy = "workPlace")
+  private List<OrganizationNode> organizationNodes;
+
+
+}

src/main/java/com/example/personnelmanager/entity/commnEntity/CustomOrder.java

+package com.example.personnelmanager.entity.commnEntity;
+
+import lombok.Data;
+import org.springframework.data.domain.Sort;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class CustomOrder
+ * @packageName com.example.personnelmanager.entity.commnEntity
+ * @data 2020/5/13
+ **/
+@Data
+public class CustomOrder {
+
+    private String coulmn;
+
+    private Sort.Direction direction;
+
+
+
+}

src/main/java/com/example/personnelmanager/entity/commnEntity/CustomPage.java

+package com.example.personnelmanager.entity.commnEntity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.util.Assert;
+import javax.validation.constraints.Min;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CustomPage {
+
+    @Min(0)
+    private Integer page = 0;
+
+    @Min(1)
+    private Integer size = 15;
+
+    private List<CustomOrder> orders = new ArrayList<>();
+
+    public Integer getPage() {
+        return page;
+    }
+
+    public void setPage(Integer page) {
+        this.page = page;
+    }
+
+    public Integer getSize() {
+        return size;
+    }
+
+    public void setSize(Integer size) {
+        Assert.isTrue(page>=0,"分页信息错误！");
+        this.size = size;
+    }
+
+    public void setOrders(List<CustomOrder> orders) {
+        this.orders = orders;
+    }
+
+    public List<CustomOrder> getOrders() {
+        return orders;
+    }
+
+    @JsonIgnore
+    public long getOffset() {
+        return page * size;
+    }
+
+    @JsonIgnore
+    public Integer getLimit() {
+        return size;
+    }
+
+    @JsonIgnore
+    public PageRequest getPageable() {
+        if (orders.size()!=0){
+            List<Sort.Order> orders = new ArrayList<>();
+            this.orders.stream().forEach(item ->
+                    orders.add(new Sort.Order(item.getDirection(),item.getCoulmn())));
+            return PageRequest.of(getPage(),getLimit(),Sort.by(orders));
+        }
+        return PageRequest.of(getPage(),getLimit());
+    }
+
+}

src/main/java/com/example/personnelmanager/entity/commnEntity/ResultObj.java

+package com.example.personnelmanager.entity.commnEntity;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.HashMap;
+
+/**
+ * 描述：标准返回类
+ *
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ResultObj
+ * @packageName com.example.demo.entity
+ * @description
+ * @data 2020/4/7
+ **/
+
+@Data
+public class ResultObj<T> {
+
+    public ResultObj(String msg) {
+        this.result = (T) new HashMap();
+        this.msg = msg;
+    }
+
+    public ResultObj(T result, String msg) {
+        this.result = result;
+        this.msg = msg;
+    }
+
+    //返回内容
+    @ApiModelProperty(value = "返回内容")
+    private T result;
+
+    //提示信息
+    @ApiModelProperty(value = "提示信息")
+    private String msg;
+
+}

src/main/java/com/example/personnelmanager/entity/dto/WorkPlaceDto.java

+package com.example.personnelmanager.entity.dto;
+
+import com.example.personnelmanager.common.validIGroup.GroupSave;
+import com.example.personnelmanager.common.validIGroup.GroupUpdate;
+import lombok.Data;
+
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class WorkPlaceRequestDto
+ * @packageName com.example.personnelmanager.entity.dto
+ * @data 2020/5/20
+ **/
+@Data
+public class WorkPlaceDto {
+
+    @Min(value = 1,groups = {GroupUpdate.class})
+    @Max(value = 0,groups = {GroupSave.class})
+    private long workPlaceId;
+
+    @NotNull(groups = {GroupSave.class,GroupUpdate.class},message = "工作地点名称不能为空")
+    private String workPlaceName;
+
+        private String workPlaceArea;
+
+    private String workPlaceAddress;
+
+    private String workPlaceType;
+
+    private String workPlaveDescript;
+
+
+}

src/main/java/com/example/personnelmanager/entity/vo/CertificatePageableVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class CertificatePageVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/18
+ **/
+@Data
+public class CertificatePageableVo extends CustomPage {
+
+    private Certificate certificate;
+
+}

src/main/java/com/example/personnelmanager/entity/vo/ContractPageableVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/13
+ **/
+@Data
+public class ContractPageableVo extends CustomPage {
+
+    private Contract contract;
+
+
+
+}

src/main/java/com/example/personnelmanager/entity/vo/LegalEntityPageableVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/13
+ **/
+@Data
+public class LegalEntityPageableVo extends CustomPage {
+
+    private LegalEntity legalEntity;
+
+
+
+}

src/main/java/com/example/personnelmanager/entity/vo/OrganizationNodeListVo.java

+package com.example.personnelmanager.entity.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class OrganizationNodeResponesListVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/18
+ **/
+@Data
+public class OrganizationNodeListVo {
+
+    public OrganizationNodeListVo(long nodeId, String nodeName, long parentNode, String nodeType) {
+        this.nodeId = nodeId;
+        this.nodeName = nodeName;
+        this.parentNode = parentNode;
+        this.nodeType = nodeType;
+    }
+
+    private long nodeId;
+
+    private String nodeName;
+
+    private long parentNode;
+
+    private String nodeType;
+
+    private List<OrganizationNodeListVo> childeNodes;
+
+    private List<PostVo> posts;
+}

src/main/java/com/example/personnelmanager/entity/vo/PeoplePageableVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.People;
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class PeopleVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/15
+ **/
+@Data
+public class PeoplePageableVo extends CustomPage {
+
+    private People people;
+}

src/main/java/com/example/personnelmanager/entity/vo/PostPageableVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.Post;
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class PostVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/19
+ **/
+@Data
+public class PostPageableVo extends CustomPage {
+
+    private Post post;
+}

src/main/java/com/example/personnelmanager/entity/vo/PostVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.OrganizationNode;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class PostListVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/19
+ **/
+@Data
+public class PostVo {
+
+    public PostVo(Long postId, String postName, String postIntroduction, Long nodeId) {
+        this.postId = postId;
+        this.postName = postName;
+        this.postIntroduction = postIntroduction;
+        this.nodeId = nodeId;
+    }
+
+    private Long postId;
+
+    private String postName;
+
+    private String postIntroduction;
+
+    private Long nodeId;
+}

src/main/java/com/example/personnelmanager/entity/vo/WorkPlacePageableVo.java

+package com.example.personnelmanager.entity.vo;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.WorkPlace;
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import lombok.Data;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityVo
+ * @packageName com.example.personnelmanager.entity.vo
+ * @data 2020/5/13
+ **/
+@Data
+public class WorkPlacePageableVo extends CustomPage {
+
+    private WorkPlace workPlace;
+
+
+
+}

src/main/java/com/example/personnelmanager/service/BasicEntityService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.commnEntity.CustomPage;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/*
+* 对于实体类进行操作的相关接口需要先实现该类获取增删改查等方法
+* */
+public interface BasicEntityService<T,S>  {
+
+    T addEntity(T t);
+
+    Page<T> getList(T t, Pageable pageable);
+
+    T update(T t);
+
+    T getOne(S id);
+
+    Boolean delete(S id);
+
+
+}

src/main/java/com/example/personnelmanager/service/CertificateImageService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.CertificateImage;
+
+public interface CertificateImageService extends BasicEntityService<CertificateImage,Long> {
+}

src/main/java/com/example/personnelmanager/service/CertificateImageServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.dao.CertificateImageRepository;
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.CertificateImage;
+import com.example.personnelmanager.entity.ContractImage;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+public class CertificateImageServiceImpl implements CertificateImageService {
+
+    @Autowired
+    CertificateImageRepository certificateImageRepository;
+
+    @Override
+    public CertificateImage addEntity(CertificateImage certificateImage) {
+        CertificateImage save = certificateImageRepository.save(certificateImage);
+        return save;
+    }
+
+    @Override
+    public Page<CertificateImage> getList(CertificateImage certificateImage, Pageable pageable) {
+        PredicateBuilder and = Specifications.<Certificate>and();
+        and.eq("ContractId",certificateImage.getCertificate().getCertificateId());
+        and.eq("deleteTag", 0);
+        Specification<Certificate> specification = and.build();
+        Page<CertificateImage> all = certificateImageRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public CertificateImage update(CertificateImage certificateImage) {
+        return null;
+    }
+
+    @Override
+    public CertificateImage getOne(Long id) {
+        Optional<CertificateImage> byId = certificateImageRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的合同不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<CertificateImage> byId = certificateImageRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的合同照片");
+        }
+        CertificateImage certificateImage = byId.get();
+        certificateImage.setDeleteTag(1);
+        certificateImageRepository.saveAndFlush(certificateImage);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/CertificateService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.Certificate;
+
+public interface CertificateService extends BasicEntityService<Certificate,Long>{
+
+}

src/main/java/com/example/personnelmanager/service/CertificateServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.CertificateRepository;
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class CertificateServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/18
+ **/
+
+@Service
+public class CertificateServiceImpl implements CertificateService {
+
+    @Autowired
+    CertificateRepository certificateRepository;
+
+    @Override
+    public Certificate addEntity(Certificate certificate) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        certificate.setEnterprise(userDetails.getEnterprise());
+        Certificate save = certificateRepository.save(certificate);
+        return save;
+    }
+
+    @Override
+    public Page<Certificate> getList(Certificate certificate, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (userDetails==null){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise()==null){
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder and = Specifications.<Certificate>and();
+        and.eq("peopleId",certificate.getPeople().getPeopleId());
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<Certificate> specification = and.build();
+        Page<Certificate> all = certificateRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public Certificate update(Certificate certificate) {
+        Certificate after = certificateRepository.saveAndFlush(certificate);
+        return after;
+    }
+
+    @Override
+    public Certificate getOne(Long id) {
+        Optional<Certificate> byId = certificateRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的合同不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<Certificate> byId = certificateRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的合同");
+        }
+        Certificate certificate = byId.get();
+        certificate.setDeleteTag(1);
+        certificateRepository.saveAndFlush(certificate);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/ContractImageService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.ContractImage;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ContractImageService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/15
+ **/
+public interface ContractImageService extends BasicEntityService<ContractImage,Long> {
+}

src/main/java/com/example/personnelmanager/service/ContractImageServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.dao.ContractImageRepository;
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.ContractImage;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ContractImageServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/15
+ **/
+@Service
+public class ContractImageServiceImpl implements ContractImageService {
+
+    @Autowired
+    ContractImageRepository contractImageRepository;
+
+
+    @Override
+    public ContractImage addEntity(ContractImage ContractImage) {
+        ContractImage save = contractImageRepository.save(ContractImage);
+        return save;
+    }
+
+    @Override
+    public Page<ContractImage> getList(ContractImage contractImage, Pageable pageable) {
+        PredicateBuilder and = Specifications.<Certificate>and();
+        and.eq("ContractId",contractImage.getContract().getContractId());
+        and.eq("deleteTag", 0);
+        Specification<Certificate> specification = and.build();
+        Page<ContractImage> all = contractImageRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public ContractImage update(ContractImage contractImage) {
+        return null;
+    }
+
+    @Override
+    public ContractImage getOne(Long id) {
+        Optional<ContractImage> byId = contractImageRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的合同不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<ContractImage> byId = contractImageRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的合同照片");
+        }
+        ContractImage contractImage = byId.get();
+        contractImage.setDeleteTag(1);
+        contractImageRepository.saveAndFlush(contractImage);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/ContractService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.ContractImage;
+
+public interface ContractService extends BasicEntityService<Contract,Long>{
+
+}

src/main/java/com/example/personnelmanager/service/ContractServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.ContractRepository;
+import com.example.personnelmanager.entity.Contract;
+import com.example.personnelmanager.entity.People;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class ContractServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/15
+ **/
+@Service
+public class ContractServiceImpl implements ContractService{
+
+    @Autowired
+    ContractRepository contractRepository;
+
+    @Override
+    public Contract addEntity(Contract contract) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        contract.setEnterprise(userDetails.getEnterprise());
+        Contract save = contractRepository.save(contract);
+        return save;
+    }
+
+    @Override
+    public Page<Contract> getList(Contract contract, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (userDetails==null){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise()==null){
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder and = Specifications.<People>and();
+        and.eq("peopleId",contract.getPeople().getPeopleId());
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<Contract> specification = and.build();
+        Page<Contract> all = contractRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public Contract update(Contract contract) {
+        Contract after = contractRepository.saveAndFlush(contract);
+        return after;
+    }
+
+    @Override
+    public Contract getOne(Long id) {
+        Optional<Contract> byId = contractRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的合同不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<Contract> byId = contractRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的合同");
+        }
+        Contract contract = byId.get();
+        contract.setDeleteTag(1);
+        contractRepository.saveAndFlush(contract);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/EducationalExperienceService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.EducationalExperience;
+
+public interface EducationalExperienceService extends BasicEntityService<EducationalExperience,Long>{
+}

src/main/java/com/example/personnelmanager/service/EducationalExperienceServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.EducationalExperienceRepository;
+import com.example.personnelmanager.entity.EducationalExperience;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class EducationalExperienceServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/20
+ **/
+public class EducationalExperienceServiceImpl implements EducationalExperienceService{
+
+    @Autowired
+    EducationalExperienceRepository educationalExperienceRepository;
+
+    @Override
+    public EducationalExperience addEntity(EducationalExperience educationalExperience) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        educationalExperience.setEnterprise(userDetails.getEnterprise());
+        EducationalExperience save = educationalExperienceRepository.save(educationalExperience);
+        return save;
+    }
+
+    @Override
+    public Page<EducationalExperience> getList(EducationalExperience educationalExperience, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (userDetails==null){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise()==null){
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder<EducationalExperience> and = Specifications.and();
+//        if (educationalExperience!=null){
+//            if (!StringUtils.isEmpty(workPlace.getWorkPlaceName())){
+//                and.like("workPlaceName","%"+workPlace.getWorkPlaceName()+"%");
+//            }
+//        }
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<EducationalExperience> specification = and.build();
+        Page<EducationalExperience> all = educationalExperienceRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public EducationalExperience update(EducationalExperience educationalExperience) {
+        EducationalExperience after = educationalExperienceRepository.saveAndFlush(educationalExperience);
+        return after;
+    }
+
+    @Override
+    public EducationalExperience getOne(Long id) {
+        Optional<EducationalExperience> byId = educationalExperienceRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的教育经历不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<EducationalExperience> byId = educationalExperienceRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的教育经历");
+        }
+        EducationalExperience educationalExperience = byId.get();
+        educationalExperience.setDeleteTag(1);
+        educationalExperienceRepository.saveAndFlush(educationalExperience);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/LegalEntityService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.LegalEntity;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+public interface LegalEntityService extends BasicEntityService<LegalEntity, Long> {
+}

src/main/java/com/example/personnelmanager/service/LegalEntityServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.LegalEntityRepository;
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.*;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+
+@Service
+public class LegalEntityServiceImpl implements LegalEntityService {
+
+    @Autowired
+    LegalEntityRepository legalEntityRepository;
+
+
+
+
+    @Override
+    public LegalEntity addEntity(LegalEntity legalEntity) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        legalEntity.setEnterprise(userDetails.getEnterprise());
+        LegalEntity save = legalEntityRepository.saveAndFlush(legalEntity);
+        return save;
+    }
+
+    @Override
+    public Page<LegalEntity> getList(LegalEntity legalEntity, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (userDetails==null){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise()==null){
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder<LegalEntity> and = Specifications.<LegalEntity>and();
+        if (legalEntity!=null){
+            if (!StringUtils.isEmpty(legalEntity.getLegalEntityName())){
+                and.like("legalEntityName","%"+legalEntity.getLegalEntityName()+"%");
+            }
+            if (!StringUtils.isEmpty(legalEntity.getSocialCreditCode())){
+                and.like("socialCreditCode","%"+legalEntity.getSocialCreditCode()+"%");
+            }
+            if (!StringUtils.isEmpty(legalEntity.getBank())){
+                and.like("bank","%"+legalEntity.getBank()+"%");
+            }
+            if (!StringUtils.isEmpty(legalEntity.getTaxDeclarationArea())){
+                and.like("taxDeclarationArea","%"+legalEntity.getTaxDeclarationArea()+"%");
+            }
+            if (!StringUtils.isEmpty(legalEntity.getAddress())){
+                and.like("address","%"+legalEntity.getAddress()+"%");
+            }
+            if (!StringUtils.isEmpty(legalEntity.getPhone())){
+                and.like("phone","%"+legalEntity.getPhone()+"%");
+            }
+        }
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<LegalEntity> specification = and.build();
+        Page<LegalEntity> all = legalEntityRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public LegalEntity update(LegalEntity legalEntity) {
+        LegalEntity after = legalEntityRepository.saveAndFlush(legalEntity);
+        return after;
+    }
+
+    @Override
+    public LegalEntity getOne(Long id) {
+        Optional<LegalEntity> byId = legalEntityRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的法律实体不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<LegalEntity> byId = legalEntityRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的法律实体");
+        }
+        LegalEntity legalEntity = byId.get();
+        legalEntity.setDeleteTag(1);
+        legalEntityRepository.saveAndFlush(legalEntity);
+        return true;
+    }
+
+}

src/main/java/com/example/personnelmanager/service/OrganizationNodeService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.OrganizationNode;
+import com.example.personnelmanager.entity.vo.OrganizationNodeListVo;
+
+import java.util.List;
+
+public interface OrganizationNodeService extends BasicEntityService<OrganizationNode,Long> {
+
+    List<OrganizationNodeListVo> getTree();
+
+}

src/main/java/com/example/personnelmanager/service/OrganizationNodeServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.OrganizationNodeRepository;
+import com.example.personnelmanager.dao.PostRepository;
+import com.example.personnelmanager.entity.OrganizationNode;
+import com.example.personnelmanager.entity.vo.OrganizationNodeListVo;
+import com.example.personnelmanager.entity.UserDetail;
+import com.example.personnelmanager.entity.vo.PostVo;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class OrganizationNodeServiceOmpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/15
+ **/
+
+@Service
+@Transactional
+public class OrganizationNodeServiceImpl implements OrganizationNodeService {
+
+    @Autowired
+    OrganizationNodeRepository organizationNodeRepository;
+
+    @Autowired
+    PostRepository postRepository;
+
+    @Override
+    public OrganizationNode addEntity(OrganizationNode organizationNode) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (organizationNode.getParentNode()!=0l){
+            OrganizationNode one = getOne(organizationNode.getParentNode());
+            if (one.getEnterprise().getEnterpriseId()!=userDetails.getEnterprise().getEnterpriseId()){
+                throw new UsernameNotFoundException("当前登录用户无权限操作该父节点");
+            }
+            organizationNode.setNodeLevel(one.getNodeLevel()+one.getNodeId()+".");
+        }else {
+            organizationNode.setNodeLevel("0.");
+        }
+        organizationNode.setEnterprise(userDetails.getEnterprise());
+        OrganizationNode save = organizationNodeRepository.saveAndFlush(organizationNode);
+        return save;
+    }
+
+    @Override
+    public Page<OrganizationNode> getList(OrganizationNode organizationNode, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        PredicateBuilder and = Specifications.<OrganizationNode>and();
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<OrganizationNode> specification = and.build();
+        Page<OrganizationNode> all = organizationNodeRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    public List<OrganizationNodeListVo> getTree(){
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        List<PostVo> postResponseListVoList = postRepository.findPostListVoByEnterpriseId(userDetails.getEnterprise().getEnterpriseId());
+        List<OrganizationNodeListVo> organizationNodeListVos = organizationNodeRepository.findTreeNode(userDetails.getEnterprise().getEnterpriseId());
+        Map<Long, List<OrganizationNodeListVo>> nodeCollect =
+                organizationNodeListVos.stream().collect(Collectors.groupingBy(OrganizationNodeListVo::getParentNode));
+        Map<Long, List<PostVo>> postCollect =
+                postResponseListVoList.stream().collect(Collectors.groupingBy(PostVo::getNodeId));
+        List<OrganizationNodeListVo> result = nodeCollect.get(0l);
+        getChild(organizationNodeListVos, nodeCollect,postCollect);
+        return result;
+    }
+
+    public void getChild(List<OrganizationNodeListVo> all, Map<Long, List<OrganizationNodeListVo>> nodeCollect, Map<Long, List<PostVo>> postCollect){
+        for (OrganizationNodeListVo parentNode: all) {
+            parentNode.setPosts(postCollect.get(parentNode.getNodeId()));
+            List<OrganizationNodeListVo> childNodeList = nodeCollect.get(parentNode.getNodeId());
+            parentNode.setChildeNodes(childNodeList);
+            if (childNodeList!=null&&childNodeList.size()>0){
+                getChild(childNodeList,nodeCollect,postCollect);
+            }
+        }
+    }
+
+    @Override
+    public OrganizationNode update(OrganizationNode organizationNode) {
+        Optional<OrganizationNode> byId = organizationNodeRepository.findById(organizationNode.getNodeId());
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要修改的节点不存在");
+        }
+        OrganizationNode one = byId.get();
+        if (one.getParentNode()==0l){
+            if (organizationNode.getParentNode()!=0l){
+                throw new GlobalException("根节点不能被移动");
+            }
+        }
+        OrganizationNode after = organizationNodeRepository.saveAndFlush(organizationNode);
+        return after;
+    }
+
+    @Override
+    public OrganizationNode getOne(Long id) {
+        Optional<OrganizationNode> byId = organizationNodeRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的节点不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<OrganizationNode> byId = organizationNodeRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的法律实体");
+        }
+        OrganizationNode one = byId.get();
+        if (one.getParentNode()==0l){
+            throw new GlobalException("根结点不能被删除");
+        }
+        organizationNodeRepository.deleteorganizationNode(id);
+        postRepository.deletePostByNodeId(id);
+
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/PeopleService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.People;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+public interface PeopleService extends BasicEntityService<People, Long> {
+}

src/main/java/com/example/personnelmanager/service/PeopleServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.PeopleRepository;
+import com.example.personnelmanager.entity.People;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+
+@Service
+public class PeopleServiceImpl implements PeopleService {
+
+    @Autowired
+    PeopleRepository peopleRepository;
+
+    @Override
+    public People addEntity(People people) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (peopleRepository.findByPhoneAndEnterprise(people.getPhone(),userDetails.getEnterprise().getEnterpriseId()).size()>0){
+            throw new GlobalException("手机号码与其他人员重复");
+        }
+        if (people.getInternshipEndTime()!=null){
+            people.setJobStatus("实习");
+        }else
+        if (people.getInternshipEndTime()!=null){
+            people.setJobStatus("试用");
+        }else {
+            people.setJobStatus("在职");
+        }
+        people.setEnterprise(userDetails.getEnterprise());
+        People save = peopleRepository.saveAndFlush(people);
+        return save;
+    }
+
+    @Override
+    public Page<People> getList(People people, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (userDetails==null){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise()==null){
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder and = Specifications.<People>and();
+        if (people!=null){
+//            if (!StringUtils.isEmpty(workPlace.getWorkPlaceArea())){
+//                and.like("taxDeclarationArea","%"+workPlace.getWorkPlaceArea()+"%");
+//            }
+        }
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<People> specification = and.build();
+        Page<People> all = peopleRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public People update(People people) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (peopleRepository.findByPhoneAndEnterprise(people.getPhone(),userDetails.getEnterprise().getEnterpriseId()).size()>0){
+            throw new GlobalException("手机号码与其他人员重复");
+        }
+        People after = peopleRepository.saveAndFlush(people);
+        return after;
+    }
+
+    @Override
+    public People getOne(Long id) {
+        Optional<People> byId = peopleRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的工作地点不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<People> byId = peopleRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的人员");
+        }
+        People people = byId.get();
+        people.setDeleteTag(1);
+        peopleRepository.saveAndFlush(people);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/PostService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.Post;
+import com.example.personnelmanager.entity.WorkPlace;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+public interface PostService extends BasicEntityService<Post, Long> {
+
+}

src/main/java/com/example/personnelmanager/service/PostServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.PostRepository;
+import com.example.personnelmanager.entity.OrganizationNode;
+import com.example.personnelmanager.entity.Post;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+
+@Service
+public class PostServiceImpl implements PostService {
+
+    @Autowired
+    PostRepository postRepository;
+
+    @Autowired
+    OrganizationNodeService organizationNodeService;
+
+    @Override
+    public Post addEntity(Post post) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        OrganizationNode one = organizationNodeService.getOne(post.getOrganizationNode().getNodeId());
+        if (one.getEnterprise().getEnterpriseId() != userDetails.getEnterprise().getEnterpriseId()) {
+            throw new UsernameNotFoundException("当前登录用户无权限操作该父节点");
+        }
+        post.setNodeLevel(one.getNodeLevel());
+        post.setEnterprise(userDetails.getEnterprise());
+        Post save = postRepository.saveAndFlush(post);
+        return save;
+    }
+
+    @Override
+    public Page<Post> getList(Post post, Pageable pageable) {
+        UserDetail userDetails = (UserDetail) AuthenticationUtils.getAuthentication();
+        if (userDetails == null) {
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise() == null) {
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder and = Specifications.<Post>and();
+        if (post != null) {
+            if (!StringUtils.isEmpty(post.getPostName())){
+                and.like("postName","%"+post.getPostName()+"%");
+            }
+            if (post.getOrganizationNode()!=null&&post.getOrganizationNode().getNodeId()>0){
+                and.eq("organizationNode",post.getOrganizationNode().getNodeId());
+            }
+        }
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<Post> specification = and.build();
+        Page<Post> all = postRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public Post update(Post post) {
+        Post after = postRepository.saveAndFlush(post);
+        return after;
+    }
+
+    @Override
+    public Post getOne(Long id) {
+        Optional<Post> byId = postRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的工作地点不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<Post> byId = postRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的工作地点");
+        }
+        Post post = byId.get();
+        post.setDeleteTag(1);
+        postRepository.saveAndFlush(post);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/TitleImageService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.Title;
+
+public interface TitleImageService extends BasicEntityService<Title,Long> {
+}

src/main/java/com/example/personnelmanager/service/TitleImageServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.dao.TitleImageRepository;
+import com.example.personnelmanager.entity.Title;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class TitleImageServiceImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/18
+ **/
+@Service
+public class TitleImageServiceImpl implements TitleImageService {
+
+    @Autowired
+    TitleImageRepository titleImageRepository;
+
+
+    @Override
+    public Title addEntity(Title title) {
+        return null;
+    }
+
+    @Override
+    public Page<Title> getList(Title title, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public Title update(Title title) {
+        return null;
+    }
+
+    @Override
+    public Title getOne(Long id) {
+        return null;
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        return null;
+    }
+}

src/main/java/com/example/personnelmanager/service/TitleService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.dao.TitleRepository;
+import com.example.personnelmanager.entity.Title;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class TitleService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/18
+ **/
+public interface TitleService extends BasicEntityService<Title,Long>{
+
+
+}

src/main/java/com/example/personnelmanager/service/TitleServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.TitleRepository;
+import com.example.personnelmanager.entity.Certificate;
+import com.example.personnelmanager.entity.Title;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class TitleService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/18
+ **/
+
+@Service
+public class TitleServiceImpl implements TitleService{
+
+    @Autowired
+    TitleRepository titleRepository;
+
+    @Override
+    public Title addEntity(Title title) {
+        UserDetail userDetails = AuthenticationUtils.getAuthentication();
+        title.setEnterprise(userDetails.getEnterprise());
+        Title save = titleRepository.save(title);
+        return save;
+    }
+
+    @Override
+    public Page<Title> getList(Title title, Pageable pageable) {
+        UserDetail userDetails = AuthenticationUtils.getAuthentication();
+        if (userDetails==null){
+            throw new UsernameNotFoundException("当前无登录用户");
+        }
+        if (userDetails.getEnterprise()==null){
+            throw new UsernameNotFoundException("当前登录用户无权限查看该单位信息");
+        }
+        PredicateBuilder and = Specifications.<Certificate>and();
+        and.eq("peopleId",title.getPeople().getPeopleId());
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<Certificate> specification = and.build();
+        Page<Title> all = titleRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public Title update(Title title) {
+        Title after = titleRepository.saveAndFlush(title);
+        return after;
+    }
+
+    @Override
+    public Title getOne(Long id) {
+        Optional<Title> byId = titleRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的工作地点不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<Title> byId = titleRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的工作地点");
+        }
+        Title title = byId.get();
+        title.setDeleteTag(1);
+        titleRepository.saveAndFlush(title);
+        return true;
+    }
+}

src/main/java/com/example/personnelmanager/service/UserServer.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.User;
+import com.example.personnelmanager.entity.UserDetail;
+
+public interface UserServer extends BasicEntityService<User,Long> {
+    UserDetail selectByUserName(String username);
+}

src/main/java/com/example/personnelmanager/service/UserServerImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.dao.UserRepository;
+import com.example.personnelmanager.entity.User;
+import com.example.personnelmanager.entity.UserDetail;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class UserServerImpl
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/14
+ **/
+@Service
+public class UserServerImpl implements UserServer {
+
+    @Autowired
+    UserRepository userRepository;
+
+    @Autowired
+    PasswordEncoder passwordEncoder;
+
+    @Override
+    public User addEntity(User user) {
+        user.setPassword(passwordEncoder.encode(user.getPassword()));
+        User addUser = userRepository.saveAndFlush(user);
+        return addUser;
+    }
+
+    @Override
+    public Page<User> getList(User user, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public User update(User user) {
+        User after = userRepository.saveAndFlush(user);
+        return after;
+    }
+
+    @Override
+    public User getOne(Long id) {
+        return null;
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<User> byId = userRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的工作地点");
+        }
+        User user = byId.get();
+        user.setDeleteTag(1);
+        userRepository.saveAndFlush(user);
+        return true;
+    }
+
+    @Override
+    public UserDetail selectByUserName(String username) {
+        if (username!=null){
+            User byUsername = userRepository.findByUsername(username);
+            if (byUsername==null){
+                throw new GlobalException("用户不存在");
+            }
+            UserDetail userDetailVo = new UserDetail();
+            BeanUtils.copyProperties(byUsername,userDetailVo);
+            if (userDetailVo.getDeleteTag()==1){
+                return null;
+            }
+            return  userDetailVo;
+        }
+        return null;
+    }
+}

src/main/java/com/example/personnelmanager/service/WorkPlaceService.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.entity.LegalEntity;
+import com.example.personnelmanager.entity.WorkPlace;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+public interface WorkPlaceService extends BasicEntityService<WorkPlace, Long> {
+}

src/main/java/com/example/personnelmanager/service/WorkPlaceServiceImpl.java

+package com.example.personnelmanager.service;
+
+import com.example.personnelmanager.common.exception.GlobalException;
+import com.example.personnelmanager.common.utils.AuthenticationUtils;
+import com.example.personnelmanager.dao.WorkPlaceRepository;
+//import com.example.personnelmanager.entity.Enterprise;
+import com.example.personnelmanager.entity.WorkPlace;
+import com.example.personnelmanager.entity.UserDetail;
+import com.github.wenhao.jpa.PredicateBuilder;
+import com.github.wenhao.jpa.Specifications;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.Optional;
+
+/**
+ * @author HuangXiahao
+ * @version V1.0
+ * @class LegalEntityService
+ * @packageName com.example.personnelmanager.service
+ * @data 2020/5/13
+ **/
+@Service
+public class WorkPlaceServiceImpl implements WorkPlaceService {
+
+    @Autowired
+    WorkPlaceRepository workPlaceRepository;
+
+    @Override
+    public WorkPlace addEntity(WorkPlace workPlace) {
+        UserDetail userDetails = AuthenticationUtils.getAuthentication();
+        workPlace.setEnterprise(userDetails.getEnterprise());
+        WorkPlace save = workPlaceRepository.save(workPlace);
+        return save;
+    }
+
+    @Override
+    public Page<WorkPlace> getList(WorkPlace workPlace, Pageable pageable) {
+        UserDetail userDetails = AuthenticationUtils.getAuthentication();
+        PredicateBuilder<WorkPlace> and = Specifications.and();
+        if (workPlace!=null){
+            if (!StringUtils.isEmpty(workPlace.getWorkPlaceName())){
+                and.like("workPlaceName","%"+workPlace.getWorkPlaceName()+"%");
+            }
+            if (!StringUtils.isEmpty(workPlace.getWorkPlaceArea())){
+                and.like("taxDeclarationArea","%"+workPlace.getWorkPlaceArea()+"%");
+            }
+            if (!StringUtils.isEmpty(workPlace.getWorkPlaceType())){
+                and.like("workPlaceType","%"+workPlace.getWorkPlaceType()+"%");
+            }
+        }
+        and.eq("enterprise", userDetails.getEnterprise().getEnterpriseId());
+        and.eq("deleteTag", 0);
+        Specification<WorkPlace> specification = and.build();
+        Page<WorkPlace> all = workPlaceRepository.findAll(specification, pageable);
+        return all;
+    }
+
+    @Override
+    public WorkPlace update(WorkPlace workPlace) {
+        WorkPlace after = workPlaceRepository.saveAndFlush(workPlace);
+        return after;
+    }
+
+    @Override
+    public WorkPlace getOne(Long id) {
+        Optional<WorkPlace> byId = workPlaceRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("所要查询的工作地点不存在");
+        }
+        return byId.get();
+    }
+
+    @Override
+    public Boolean delete(Long id) {
+        Optional<WorkPlace> byId = workPlaceRepository.findById(id);
+        if (!byId.isPresent()) {
+            throw new GlobalException("不存在需要被删除的工作地点");
+        }
+        WorkPlace workPlace = byId.get();
+        workPlace.setDeleteTag(1);
+        workPlaceRepository.saveAndFlush(workPlace);
+        return true;
+    }
+}

src/main/resources/application.yml

+
+server:
+  port: 8080
+spring:
+  datasource:
+    url: jdbc:mysql://47.106.142.73:3306/PersonnelManager?serverTimezone=Asia/Shanghai&characterEncoding=UTF-8
+    password: Huang123+
+    username: root
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    hikari:
+      auto-commit: false
+  jpa:
+    hibernate:
+      ddl-auto: update
+    show-sql: true
+    open-in-view: true
+    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
+    database: mysql
+
+
+    properties:
+      hibernate:
+        enable_lazy_load_no_trans=true:jooq:
+    sql-dialect: MySQL5Dialect
+  jackson:
+    date-format: yyyy-MM-dd-HH:mm:ss
+    time-zone: GMT+8
+file:
+  rootPath: G:/IdeaProjects/personnelmanager/target/classes/images
\ No newline at end of file

src/test/java/com/example/personnelmanager/PersonnelmanagerApplicationTests.java

+package com.example.personnelmanager;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class PersonnelmanagerApplicationTests {
+
+    @Test
+    void contextLoads() {
+    }
+
+}