实验室信息管理系统的架构说明

已于 2023-04-21 15:30:05 修改
阅读量676 收藏 2
点赞数 1
分类专栏： 实验室 lims 信息化管理 文章标签： 系统架构
于 2023-04-21 14:25:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wx15813375802/article/details/130287706
版权
本文介绍了实验室信息管理系统的架构，包括数据库层、应用层、用户界面层、安全层、数据分析层和通信层。数据库层存储各类实验室信息，应用层实现设备、试剂、文献等管理功能，用户界面提供Web和移动端交互，安全层保障信息安全性，数据分析层进行数据挖掘，通信层实现与其他系统的数据交换。
摘要由CSDN通过智能技术生成

  1. 数据库层：用于存储实验室的各种信息，包括实验室设备、试剂、文献、人员等。

  2. 应用层：用于实现实验室信息管理系统的各种功能，包括设备管理、试剂管理、文献管理、人员管理、实验计划管理、实验数据管理等。

  3. 用户界面层：用于提供用户与实验室信息管理系统进行交互的界面，包括Web界面、移动端界面等。

  4. 安全层：用于保障实验室信息的安全性，包括用户身份验证、数据加密、访问控制等。

  5. 数据分析层：用于对实验室信息进行分析和挖掘，以提供决策支持和优化实验室管理。

  6. 通信层：用于实现实验室信息管理系统与其他系统的数据交换和通信，包括与仪器设备的通信、与实验室信息系统的集成等。

package co.fuyond;import co.fuyond.annotation.AnonymousAccess;

import co.fuyond.utils.SpringContextHolder;

import com.binarywang.spring.starter.wxjava.miniapp.config.WxMaAutoConfiguration;

import org.mybatis.spring.annotation.MapperScan;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;

import org.springframework.boot.web.servlet.server.ServletWebServerFactory;

import org.springframework.context.annotation.Bean;

import org.springframework.scheduling.annotation.EnableAsync;

import org.springframework.transaction.annotation.EnableTransactionManagement;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RestController;@EnableAsync

@RestController

@SpringBootApplication(exclude = {WxMaAutoConfiguration.class})

@EnableTransactionManagement

@MapperScan(basePackages = {"co.fuyond.modules.*.service.mapper", "co.fuyond.config", "co.fuyond.mapper"})

public class AppRun {

    public static void main(String[] args) {

        SpringApplication.run(AppRun.class, args);

        System.out.println(

                "              __                  \n" +

                        "  __ __ ___  / /  ___   ___       \n" +

                        " / // /(_-< / _ \\/ _ \\ / _ \\   \n" +

                        " \\_, //___//_//_/\\___// .__/    \n" +

                        "/___/                /_/          \n " + "\n系统管理后台启动成功 \n");

    }    @Bean

    public SpringContextHolder springContextHolder() {

        return new SpringContextHolder();

    }    @Bean

    public ServletWebServerFactory webServerFactory() {

        TomcatServletWebServerFactory fa = new TomcatServletWebServerFactory();

        fa.addConnectorCustomizers(connector -> connector.setProperty("relaxedQueryChars", "[]{}"));

        return fa;

    }    /**

     * 访问首页提示

     *

     * @return /

     */

    @GetMapping("/")

    @AnonymousAccess

    public String index() {

        return "Backend service started successfully";

    }

}

package co.fuyond.config;import org.springframework.beans.factory.annotation.Value;

        import org.springframework.context.annotation.Bean;

        import org.springframework.context.annotation.Configuration;

        import org.springframework.web.cors.CorsConfiguration;

        import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

        import org.springframework.web.filter.CorsFilter;

        import org.springframework.web.servlet.config.annotation.EnableWebMvc;

        import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;

        import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration(proxyBeanMethods = false)

@EnableWebMvc

public class ConfigurerAdapter implements WebMvcConfigurer {

    @Value("${file.path}")

    private String path;

    @Value("${file.avatar}")

    private String avatar;    @Bean

    public CorsFilter corsFilter() {

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        CorsConfiguration config = new CorsConfiguration();

        // 允许cookies跨域

        config.setAllowCredentials(true);

        // #允许向该服务器提交请求的URI，*表示全部允许，在SpringMVC中，如果设成*，会自动转成当前请求头中的Origin

        config.addAllowedOriginPattern("*");

        // #允许访问的头信息,*表示全部

        config.addAllowedHeader("*");

        // 预检请求的缓存时间（秒），即在这个时间段里，对于相同的跨域请求不会再预检了

        config.setMaxAge(18000L);

        // 允许提交请求的方法类型，*表示全部允许

        config.addAllowedMethod("OPTIONS");

        config.addAllowedMethod("HEAD");

        config.addAllowedMethod("GET");

        config.addAllowedMethod("PUT");

        config.addAllowedMethod("POST");

        config.addAllowedMethod("DELETE");

        config.addAllowedMethod("PATCH");

        source.registerCorsConfiguration("/**", config);

        return new CorsFilter(source);

    }    @Override

    public void addResourceHandlers(ResourceHandlerRegistry registry) {

        String avatarUtl = "file:" + avatar.replace("\\", "/");

        String pathUtl = "file:" + path.replace("\\", "/");

        registry.addResourceHandler("/avatar/**").addResourceLocations(avatarUtl).setCachePeriod(0);

        registry.addResourceHandler("/file/**").addResourceLocations(pathUtl).setCachePeriod(0);

        registry.addResourceHandler("/**").addResourceLocations("classpath:/META-INF/resources/").setCachePeriod(0);

    }

}

package co.fuyond.config;

        import co.fuyond.modules.system.domain.Dept;

        import co.fuyond.modules.system.service.DeptService;

        import co.fuyond.modules.system.service.RoleService;

        import co.fuyond.modules.system.service.UserService;

        import co.fuyond.modules.system.service.dto.RoleSmallDto;

        import co.fuyond.modules.system.service.dto.UserDto;

        import co.fuyond.utils.SecurityUtils;

        import org.springframework.stereotype.Component;

        import java.util.ArrayList;

        import java.util.HashSet;

        import java.util.List;

        import java.util.Set;/**

 * 数据权限配置

 *

 * @author hupeng

 */

@Component

public class DataScope {

    private final String[] scopeType = {"全部", "本级", "自定义"};

    private final UserService userService;

    private final RoleService roleService;

    private final DeptService deptService;    public DataScope(UserService userService, RoleService roleService, DeptService deptService) {

        this.userService = userService;

        this.roleService = roleService;

        this.deptService = deptService;

    }    public Set<Long> getDeptIds() {

        UserDto user = userService.findByName(SecurityUtils.getUsername());        // 用于存储部门id

        Set<Long> deptIds = new HashSet<>();        // 查询用户角色

        List<RoleSmallDto> roleSet = roleService.findByUsersId(user.getId());

        for (RoleSmallDto role : roleSet) {

            if (scopeType[0].equals(role.getDataScope())) {

                return new HashSet<>();

            }            // 存储本级的数据权限

            if (scopeType[1].equals(role.getDataScope())) {

                deptIds.add(user.getDept().getId());

            }            // 存储自定义的数据权限

            if (scopeType[2].equals(role.getDataScope())) {

                Set<Dept> depts = deptService.findByRoleIds(role.getId());

                for (Dept dept : depts) {

                    deptIds.add(dept.getId());

                    List<Dept> deptChildren = deptService.findByPid(dept.getId());

                    if (deptChildren != null && deptChildren.size() != 0) {

                        deptIds.addAll(getDeptChildren(deptChildren));

                    }

                }

            }

        }

        return deptIds;

    }    public List<Long> getDeptChildren(List<Dept> deptList) {

        List<Long> list = new ArrayList<>();

        deptList.forEach(dept -> {

                    if (dept != null && dept.getEnabled()) {

                        List<Dept> depts = deptService.findByPid(dept.getId());

                        if (deptList.size() != 0) {

                            list.addAll(getDeptChildren(depts));

                        }

                        list.add(dept.getId());

                    }

                }

        );

        return list;

    }

}

package co.fuyond.config;

        import com.baomidou.mybatisplus.annotation.DbType;

        import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;

        import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;

        import org.springframework.context.annotation.Bean;

        import org.springframework.context.annotation.Configuration;/**

 * MybatisPlus配置

 */

@Configuration(proxyBeanMethods = false)

public class MybatisPlusConfig {

    /**

     * mybatis-plus分页插件

     */

    @Bean

    public MybatisPlusInterceptor mybatisPlusInterceptor() {

        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));

        return interceptor;

    }

}

package co.fuyond.config;import org.springframework.context.annotation.Bean;

        import org.springframework.context.annotation.Configuration;

        import org.springframework.web.socket.server.standard.ServerEndpointExporter;/**

 * @author: ZhangHouYing

 */

@Configuration(proxyBeanMethods = false)

public class WebSocketConfig {

    @Bean

    public ServerEndpointExporter serverEndpointExporter() {

        return new ServerEndpointExporter();

    }

}package co.fuyond.config.thread;import lombok.extern.slf4j.Slf4j;

        import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;

        import org.springframework.context.annotation.Configuration;

        import org.springframework.scheduling.annotation.AsyncConfigurer;

        import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.Executor;

        import java.util.concurrent.ThreadPoolExecutor;/**

 * 异步任务线程池装配类

 *

 * @author https://juejin.im/entry/5abb8f6951882555677e9da2

 */

@Slf4j

@Configuration(proxyBeanMethods = false)

public class AsyncTaskExecutePool implements AsyncConfigurer {

    /**

     * 注入配置类

     */

    private final AsyncTaskProperties config;    public AsyncTaskExecutePool(AsyncTaskProperties config) {

        this.config = config;

    }    @Override

    public Executor getAsyncExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        //核心线程池大小

        executor.setCorePoolSize(config.getCorePoolSize());

        //最大线程数

        executor.setMaxPoolSize(config.getMaxPoolSize());

        //队列容量

        executor.setQueueCapacity(config.getQueueCapacity());

        //活跃时间

        executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

        //线程名字前缀

        executor.setThreadNamePrefix("el-async-");

        // setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

        // CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        executor.initialize();

        return executor;

    }    @Override

    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

        return (throwable, method, objects) -> {

            log.error("====" + throwable.getMessage() + "====", throwable);

            log.error("exception method:" + method.getName());

        };

    }

}package co.fuyond.config.thread;import lombok.Data;

        import org.springframework.boot.context.properties.ConfigurationProperties;

        import org.springframework.stereotype.Component;/**

 * 线程池配置属性类

 *

 * @author https://juejin.im/entry/5abb8f6951882555677e9da2

 */

@Data

@Component

@ConfigurationProperties(prefix = "task.pool")

public class AsyncTaskProperties {

    private int corePoolSize;

    private int maxPoolSize;

    private int keepAliveSeconds;

    private int queueCapacity;

}package co.fuyond.config.thread;import org.springframework.stereotype.Component;import java.util.concurrent.ThreadFactory;

        import java.util.concurrent.atomic.AtomicInteger;@Component

public class TheadFactoryName implements ThreadFactory {

    private static final AtomicInteger POOL_NUMBER = new AtomicInteger(1);

    private final ThreadGroup group;

    private final AtomicInteger threadNumber = new AtomicInteger(1);

    private final String namePrefix;    public TheadFactoryName() {

        this("el-pool");

    }    private TheadFactoryName(String name) {

        SecurityManager s = System.getSecurityManager();

        group = (s != null) ? s.getThreadGroup() :

                Thread.currentThread().getThreadGroup();

        //此时namePrefix就是 name + 第几个用这个工厂创建线程池的

        this.namePrefix = name +

                POOL_NUMBER.getAndIncrement();

    }    @Override

    public Thread newThread(Runnable r) {

        //此时线程的名字 就是 namePrefix + -thread- + 这个线程池中第几个执行的线程

        Thread t = new Thread(group, r,

                namePrefix + "-thread-" + threadNumber.getAndIncrement(),

                0);

        if (t.isDaemon()) {

            t.setDaemon(false);

        }

        if (t.getPriority() != Thread.NORM_PRIORITY) {

            t.setPriority(Thread.NORM_PRIORITY);

        }

        return t;

    }

}package co.fuyond.config.thread;import co.fuyond.utils.SpringContextHolder;import java.util.concurrent.ArrayBlockingQueue;

        import java.util.concurrent.ThreadPoolExecutor;

        import java.util.concurrent.TimeUnit;public class ThreadPoolExecutorUtil {

    public static ThreadPoolExecutor getPoll() {

        AsyncTaskProperties properties = SpringContextHolder.getBean(AsyncTaskProperties.class);

        return new ThreadPoolExecutor(

                properties.getCorePoolSize(),

                properties.getMaxPoolSize(),

                properties.getKeepAliveSeconds(),

                TimeUnit.SECONDS,

                new ArrayBlockingQueue<>(properties.getQueueCapacity()),

                new TheadFactoryName()

        );

    }

}

package co.fuyond.controller;

        import co.fuyond.domain.HrAgreement;        import co.fuyond.domain.PageResult;        import co.fuyond.dozer.service.IGenerator;        import co.fuyond.dto.HrAgreementDto;        import co.fuyond.dto.HrAgreementQueryCriteria;        import co.fuyond.modules.logging.aop.log.Log;        import co.fuyond.service.HrAgreementService;        import io.swagger.annotations.Api;        import io.swagger.annotations.ApiOperation;        import lombok.AllArgsConstructor;        import org.springframework.beans.factory.annotation.Autowired;        import org.springframework.data.domain.Pageable;        import org.springframework.http.HttpStatus;        import org.springframework.http.ResponseEntity;        import org.springframework.security.access.prepost.PreAuthorize;        import org.springframework.validation.annotation.Validated;        import org.springframework.web.bind.annotation.*;

        import javax.servlet.http.HttpServletResponse;        import java.io.IOException;        import java.util.Arrays;

/**

 * @author liutao

 * @createDate 2023-03-27 13:24:00

 */@AllArgsConstructor@Api(tags = "WEBhr_agreement管理")@RestController@RequestMapping("/api/hrAgreement")public class HrAgreementController {

    private final IGenerator generator;    @Autowired    private HrAgreementService hrAgreementService;

    @Log("导出数据")    @ApiOperation("导出数据")    @GetMapping(value = "/download")    @PreAuthorize("@el.check('admin','hrAgreement:list')")    public void download(HttpServletResponse response, HrAgreementQueryCriteria criteria) throws IOException {        hrAgreementService.download(generator.convert(hrAgreementService.queryAll(criteria), HrAgreementDto.class), response);    }

    @GetMapping    @Log("查询hr_agreement")    @ApiOperation("查询hr_agreement")    @PreAuthorize("@el.check('admin','hrAgreement:list')")    public ResponseEntity<PageResult<HrAgreementDto>> getHrAgreements(HrAgreementQueryCriteria criteria, Pageable pageable) {        return new ResponseEntity<>(hrAgreementService.queryAll(criteria, pageable), HttpStatus.OK);    }

    @PostMapping    @Log("新增hr_agreement")    @ApiOperation("新增hr_agreement")    @PreAuthorize("@el.check('admin','hrAgreement:add')")    public ResponseEntity<Object> create(@Validated @RequestBody HrAgreement resources) {        return new ResponseEntity<>(hrAgreementService.save(resources), HttpStatus.CREATED);    }

    @PutMapping    @Log("修改hr_agreement")    @ApiOperation("修改hr_agreement")    @PreAuthorize("@el.check('admin','hrAgreement:edit')")    public ResponseEntity<Object> update(@Validated @RequestBody HrAgreement resources) {        hrAgreementService.updateById(resources);        return new ResponseEntity<>(HttpStatus.NO_CONTENT);    }

    @Log("删除hr_agreement")    @ApiOperation("删除hr_agreement")    @PreAuthorize("@el.check('admin','hrAgreement:del')")    @DeleteMapping    public ResponseEntity<Object> deleteAll(@RequestBody Long[] ids) {        Arrays.asList(ids).forEach(id -> {            hrAgreementService.removeById(id);        });        return new ResponseEntity<>(HttpStatus.OK);    }}package co.fuyond.controller;

        import co.fuyond.domain.HrBanner;        import co.fuyond.domain.PageResult;        import co.fuyond.dozer.service.IGenerator;        import co.fuyond.dto.HrBannerDto;        import co.fuyond.dto.HrBannerQueryCriteria;        import co.fuyond.modules.logging.aop.log.Log;        import co.fuyond.service.HrBannerService;        import io.swagger.annotations.Api;        import io.swagger.annotations.ApiOperation;        import lombok.AllArgsConstructor;        import org.springframework.beans.factory.annotation.Autowired;        import org.springframework.data.domain.Pageable;        import org.springframework.http.HttpStatus;        import org.springframework.http.ResponseEntity;        import org.springframework.security.access.prepost.PreAuthorize;        import org.springframework.validation.annotation.Validated;        import org.springframework.web.bind.annotation.*;

        import javax.servlet.http.HttpServletResponse;        import java.io.IOException;        import java.util.Arrays;

/**

 * @author liutao

 * @createDate 2023-03-27 13:24:00

 */@AllArgsConstructor@Api(tags = "hr_banner管理")@RestController@RequestMapping("/api/hrBanner")public class HrBannerController {

    private final IGenerator generator;    @Autowired    private HrBannerService hrBannerService;

    @Log("导出数据")    @ApiOperation("导出数据")    @GetMapping(value = "/download")    @PreAuthorize("@el.check('admin','hrBanner:list')")    public void download(HttpServletResponse response, HrBannerQueryCriteria criteria) throws IOException {        hrBannerService.download(generator.convert(hrBannerService.queryAll(criteria), HrBannerDto.class), response);    }

    @GetMapping    @Log("查询hr_banner")    @ApiOperation("查询hr_banner")    @PreAuthorize("@el.check('admin','hrBanner:list')")    public ResponseEntity<PageResult<HrBannerDto>> getHrBanners(HrBannerQueryCriteria criteria, Pageable pageable) {        return new ResponseEntity<>(hrBannerService.queryAll(criteria, pageable), HttpStatus.OK);    }

    @PostMapping    @Log("新增hr_banner")    @ApiOperation("新增hr_banner")    @PreAuthorize("@el.check('admin','hrBanner:add')")    public ResponseEntity<Object> create(@Validated @RequestBody HrBanner resources) {        return new ResponseEntity<>(hrBannerService.save(resources), HttpStatus.CREATED);    }

    @PutMapping    @Log("修改hr_banner")    @ApiOperation("修改hr_banner")    @PreAuthorize("@el.check('admin','hrBanner:edit')")    public ResponseEntity<Object> update(@Validated @RequestBody HrBanner resources) {        hrBannerService.updateById(resources);        return new ResponseEntity<>(HttpStatus.NO_CONTENT);    }

    @Log("删除hr_banner")    @ApiOperation("删除hr_banner")    @PreAuthorize("@el.check('admin','hrBanner:del')")    @DeleteMapping    public ResponseEntity<Object> deleteAll(@RequestBody Long[] ids) {        Arrays.asList(ids).forEach(id -> {            hrBannerService.removeById(id);        });        return new ResponseEntity<>(HttpStatus.OK);    }}

package co.fuyond.controller;import co.fuyond.domain.HrDelivery;

        import co.fuyond.domain.PageResult;

        import co.fuyond.dozer.service.IGenerator;

        import co.fuyond.dto.HrDeliveryDto;

        import co.fuyond.dto.HrDeliveryQueryCriteria;

        import co.fuyond.dto.HrResumeDto;

        import co.fuyond.dto.HrResumeQueryCriteria;

        import co.fuyond.modules.logging.aop.log.Log;

        import co.fuyond.modules.security.security.vo.JwtUser;

        import co.fuyond.service.HrDeliveryService;

        import co.fuyond.service.HrResumeService;

        import co.fuyond.vo.HrStudentResumeVo;

        import io.swagger.annotations.Api;

        import io.swagger.annotations.ApiOperation;

        import lombok.AllArgsConstructor;

        import org.springframework.beans.factory.annotation.Autowired;

        import org.springframework.data.domain.Pageable;

        import org.springframework.http.HttpStatus;

        import org.springframework.http.ResponseEntity;

        import org.springframework.security.access.prepost.PreAuthorize;

        import org.springframework.security.core.annotation.AuthenticationPrincipal;

        import org.springframework.security.core.userdetails.UserDetails;

        import org.springframework.validation.annotation.Validated;

        import org.springframework.web.bind.annotation.*;import javax.servlet.http.HttpServletResponse;

        import java.io.IOException;

        import java.util.ArrayList;

        import java.util.Arrays;

        import java.util.List;/**

 * @author liutao

 * @createDate 2023-03-27 13:24:00

 */

@AllArgsConstructor

@Api(tags = "WEB简历投递管理")

@RestController

@RequestMapping("/api/hrDelivery")

public class HrDeliveryController {

    private final IGenerator generator;

    @Autowired

    private HrDeliveryService hrDeliveryService;

    @Autowired

    private HrResumeService hrResumeService;    @Log("导出数据")

    @ApiOperation("web导出数据")

    @GetMapping(value = "/download")

    @PreAuthorize("@el.check('admin','hrDelivery:list')")

    public void download(HttpServletResponse response, HrDeliveryQueryCriteria criteria) throws IOException {

        hrDeliveryService.download(generator.convert(hrDeliveryService.queryAll(criteria), HrDeliveryDto.class), response);

    }    @GetMapping

    @Log("查询hr_delivery")

    @ApiOperation("web查询hr_delivery")

    @PreAuthorize("@el.check('admin','hrDelivery:list')")

    public ResponseEntity<PageResult<HrDeliveryDto>> getHrDeliverys(HrDeliveryQueryCriteria criteria, Pageable pageable) {

        return new ResponseEntity<>(hrDeliveryService.queryAll(criteria, pageable), HttpStatus.OK);

    }    @PostMapping

    @Log("新增hr_delivery")

    @ApiOperation("web新增hr_delivery")

    @PreAuthorize("@el.check('admin','hrDelivery:add')")

    public ResponseEntity<Object> create(@Validated @RequestBody HrDelivery resources) {

        return new ResponseEntity<>(hrDeliveryService.save(resources), HttpStatus.CREATED);

    }    @PutMapping

    @Log("修改hr_delivery")

    @ApiOperation("web修改hr_delivery")

    @PreAuthorize("@el.check('admin','hrDelivery:edit')")

    public ResponseEntity<Object> update(@Validated @RequestBody HrDelivery resources) {

        hrDeliveryService.updateById(resources);

        return new ResponseEntity<>(HttpStatus.NO_CONTENT);

    }    @Log("删除hr_delivery")

    @ApiOperation("web删除hr_delivery")

    @PreAuthorize("@el.check('admin','hrDelivery:del')")

    @DeleteMapping

    public ResponseEntity<Object> deleteAll(@RequestBody Long[] ids) {

        Arrays.asList(ids).forEach(id -> {

            hrDeliveryService.removeById(id);

        });

        return new ResponseEntity<>(HttpStatus.OK);

    }    /**

     * 获取单个简历详细信息

     *

     * @param resumeId 简历id

     * @return 简历全部信息

     */

    @GetMapping("/studentResumeInfo")

    @PreAuthorize("@el.check('admin','hrDelivery:list')")

    public ResponseEntity<HrStudentResumeVo> getStudentResumesInfo(@RequestParam Long resumeId) {

        HrStudentResumeVo resumeVo = hrResumeService.getStudentResumesInfo(resumeId);

        return new ResponseEntity<>(resumeVo, HttpStatus.OK);

    }    /**

     * 获取当前企业收到的简历

     *

     * @param userDetails 当前登录信息

     * @param pageable    分页参数

     * @param criteria    查询条件

     * @return 简历信息

     */

    @GetMapping("/studentResume")

    @PreAuthorize("@el.check('admin','hrDelivery:list')")

    public ResponseEntity<PageResult<HrResumeDto>> getStudentResumes(@AuthenticationPrincipal UserDetails userDetails, Pageable pageable, HrResumeQueryCriteria criteria) {

        JwtUser user = (JwtUser) userDetails;

        if (user.getEnterpriseAuthentication().equals(1)) {

            return new ResponseEntity<>(hrDeliveryService.getStudentResumesByEnterpriseId(user.getEnterpriseInfoId(), criteria, pageable), HttpStatus.OK);

        }

        return null;

    }    /**

     * 根据招聘id获取招聘下所有简历信息

     *

     * @param employmentId 招聘id

     * @return 简历信息

     */

    @GetMapping("/getResumeByEmploymentId")

    @PreAuthorize("@el.check('admin','hrDelivery:list')")

    public ResponseEntity<List<HrStudentResumeVo>> getResumeByEmploymentId(@RequestParam Long employmentId) {

        ArrayList<HrStudentResumeVo> resumeVos = hrResumeService.getResumeInfoByEmploymentId(employmentId);

        return new ResponseEntity<>(resumeVos, HttpStatus.OK);

    }

}package co.fuyond.controller;import co.fuyond.domain.HrEmployment;

        import co.fuyond.domain.PageResult;

        import co.fuyond.dozer.service.IGenerator;

        import co.fuyond.dto.HrEmploymentDto;

        import co.fuyond.dto.HrEmploymentEnterpriseInfoDto;

        import co.fuyond.dto.HrEmploymentQueryCriteria;

        import co.fuyond.modules.logging.aop.log.Log;

        import co.fuyond.modules.security.security.vo.JwtUser;

        import co.fuyond.service.HrEmploymentService;

        import io.swagger.annotations.Api;

        import io.swagger.annotations.ApiOperation;

        import lombok.AllArgsConstructor;

        import org.springframework.beans.factory.annotation.Autowired;

        import org.springframework.data.domain.Pageable;

        import org.springframework.http.HttpStatus;

        import org.springframework.http.ResponseEntity;

        import org.springframework.security.access.prepost.PreAuthorize;

        import org.springframework.security.core.annotation.AuthenticationPrincipal;

        import org.springframework.security.core.userdetails.UserDetails;

        import org.springframework.validation.annotation.Validated;

        import org.springframework.web.bind.annotation.*;import javax.servlet.http.HttpServletResponse;

        import java.io.IOException;

        import java.util.Arrays;/**

 * @author liutao

 * @createDate 2023-03-27 13:24:00

 */

@AllArgsConstructor

@Api(tags = "WEB招聘信息管理")

@RestController

@RequestMapping("/api/hrEmployment")

public class HrEmploymentController {

    private final IGenerator generator;

    @Autowired

    private HrEmploymentService hrEmploymentService;    @Log("导出数据")

    @ApiOperation("web导出数据")

    @GetMapping(value = "/download")

    @PreAuthorize("@el.check('admin','hrEmployment:list')")

    public void download(HttpServletResponse response, HrEmploymentQueryCriteria criteria) throws IOException {

        hrEmploymentService.download(generator.convert(hrEmploymentService.queryAll(criteria), HrEmploymentDto.class), response);

    }    @GetMapping

    @Log("查询hr_employment")

    @ApiOperation("web查询hr_employment")

    @PreAuthorize("@el.check('admin','hrEmployment:list')")

    public ResponseEntity<PageResult<HrEmploymentDto>> getHrEmployments(HrEmploymentQueryCriteria criteria, Pageable pageable) {

        return new ResponseEntity<>(hrEmploymentService.queryAll(criteria, pageable), HttpStatus.OK);

    }    @PostMapping

    @Log("新增hr_employment")

    @ApiOperation("web新增hr_employment")

    @PreAuthorize("@el.check('admin','hrEmployment:add')")

    public ResponseEntity<Object> create(@Validated @RequestBody HrEmployment resources, @AuthenticationPrincipal UserDetails userDetails) {

        JwtUser user = (JwtUser) userDetails;

        resources.setEnterpriseInfoId(user.getEnterpriseInfoId());

        return new ResponseEntity<>(hrEmploymentService.save(resources), HttpStatus.CREATED);

    }    @PutMapping

    @Log("修改hr_employment")

    @ApiOperation("web修改hr_employment")

    @PreAuthorize("@el.check('admin','hrEmployment:edit')")

    public ResponseEntity<Object> update(@Validated @RequestBody HrEmployment resources) {

        hrEmploymentService.updateById(resources);

        return new ResponseEntity<>(HttpStatus.NO_CONTENT);

    }    @Log("删除hr_employment")

    @ApiOperation("web删除hr_employment")

    @PreAuthorize("@el.check('admin','hrEmployment:del')")

    @DeleteMapping

    public ResponseEntity<Object> deleteAll(@RequestBody Long[] ids) {

        Arrays.asList(ids).forEach(id -> {

            hrEmploymentService.delById(id);

        });

        return new ResponseEntity<>(HttpStatus.OK);

    }    /**

     * web获取招聘信息和企业部分信息

     *

     * @param name     搜索招聘/企业名字

     * @param pageable 分页参数

     * @return

     */

    @GetMapping("/getInfo")

    @PreAuthorize("@el.check('admin','hrEmployment:list')")

    public ResponseEntity<PageResult<HrEmploymentEnterpriseInfoDto>> getAndEnterpriseInfo(String name, Pageable pageable) {

        return new ResponseEntity<>(hrEmploymentService.findAndEnterpriseInfo(name, pageable), HttpStatus.OK);

    }

}package co.fuyond.controller;import co.fuyond.domain.HrEnterpriseInfo;

        import co.fuyond.domain.PageResult;

        import co.fuyond.dozer.service.IGenerator;

        import co.fuyond.dto.HrEnterpriseInfoDto;

        import co.fuyond.dto.HrEnterpriseInfoQueryCriteria;

        import co.fuyond.modules.logging.aop.log.Log;

        import co.fuyond.modules.security.security.vo.JwtUser;

        import co.fuyond.modules.system.domain.User;

        import co.fuyond.modules.system.domain.UsersRoles;

        import co.fuyond.modules.system.service.UserService;

        import co.fuyond.modules.system.service.UsersRolesService;

        import co.fuyond.service.HrEnterpriseInfoService;

        import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

        import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;

        import io.swagger.annotations.Api;

        import io.swagger.annotations.ApiOperation;

        import lombok.AllArgsConstructor;

        import org.springframework.beans.factory.annotation.Autowired;

        import org.springframework.data.domain.Pageable;

        import org.springframework.http.HttpStatus;

        import org.springframework.http.ResponseEntity;

        import org.springframework.security.access.prepost.PreAuthorize;

        import org.springframework.security.core.annotation.AuthenticationPrincipal;

        import org.springframework.security.core.userdetails.UserDetails;

        import org.springframework.validation.annotation.Validated;

        import org.springframework.web.bind.annotation.*;import javax.servlet.http.HttpServletResponse;

        import java.io.IOException;

        import java.util.Arrays;

        import java.util.List;/**

 * @author liutao

 * @createDate 2023-03-27 13:24:00

 */

@AllArgsConstructor

@Api(tags = "WEB企业信息管理")

@RestController

@RequestMapping("/api/hrEnterpriseInfo")

public class HrEnterpriseInfoController {

    private final IGenerator generator;

    @Autowired

    private HrEnterpriseInfoService hrEnterpriseInfoService;

    @Autowired

    private UserService userService;

    @Autowired

    private UsersRolesService usersRolesService;    @Log("导出数据")

    @ApiOperation("web导出数据")

    @GetMapping(value = "/download")

    @PreAuthorize("@el.check('admin','hrEnterpriseInfo:list')")

    public void download(HttpServletResponse response, HrEnterpriseInfoQueryCriteria criteria) throws IOException {

        hrEnterpriseInfoService.download(generator.convert(hrEnterpriseInfoService.queryAll(criteria), HrEnterpriseInfoDto.class), response);

    }    @GetMapping

    @Log("查询hr_enterprise_info")

    @ApiOperation("web查询hr_enterprise_info")

    @PreAuthorize("@el.check('admin','hrEnterpriseInfo:list')")

    public ResponseEntity<PageResult<HrEnterpriseInfoDto>> getHrEnterpriseInfos(HrEnterpriseInfoQueryCriteria criteria, Pageable pageable) {

        PageResult<HrEnterpriseInfoDto> pageResult = hrEnterpriseInfoService.queryAll(criteria, pageable);

        for (HrEnterpriseInfoDto dto : pageResult.getContent()) {

            User user = userService.getOne(new QueryWrapper<User>().eq("enterprise_info_id", dto.getId()).select("id", "enterprise_authentication"));

            if (user != null && user.getEnterpriseAuthentication() != null) {

                dto.setEnterpriseAuthentication(user.getEnterpriseAuthentication());

            }

        }

        return new ResponseEntity<>(pageResult, HttpStatus.OK);

    }    @PostMapping

    @Log("新增hr_enterprise_info")

    @ApiOperation("web新增hr_enterprise_info")

    @PreAuthorize("@el.check('admin','hrEnterpriseInfo:add')")

    public ResponseEntity<Object> create(@Validated @RequestBody HrEnterpriseInfo resources) {

        return new ResponseEntity<>(hrEnterpriseInfoService.save(resources), HttpStatus.CREATED);

    }    @PutMapping

    @Log("修改hr_enterprise_info")

    @ApiOperation("web修改hr_enterprise_info")

    @PreAuthorize("@el.check('admin','hrEnterpriseInfo:edit')")

    public ResponseEntity<Object> update(@Validated @RequestBody HrEnterpriseInfo resources) {

        hrEnterpriseInfoService.updateById(resources);

        return new ResponseEn

最低0.47元/天 解锁文章
按下F5
关注
专栏目录
实验室信息管理系统
fqfq123456的专栏
05-20 1143
实验室信息管理系统，主要功能包括监测业务全流程管理，实现人员、仪器设备、试剂、标样、方法标准等资源的全面资源管理、实现全面质控等。 系统可以根据业务类型的不同，可由多个部门、多个人员分别承接不同类型的业务。政府计划性业务主要包含环境质量监测、污染源监测、污染源在线比对等；政府非计划性业务包括信访监测、应急监测、环境执法监测、专项调查等；社会委托（验收）主要包括委托分析、委托监测、环评、企业年审、验收监测、社会服务性监测等。 监测要素包含废水、地表水、降水、地下水、噪声、振动、环境空气、废气、室内空气、土
LIMS（实验室）信息管理系统源码：系统构架组成与功能实现
爱笑的源码博客
06-15 544
实验室其他管理信息体系模块： ①.实验室专业分组管理； ②.仪器台帐定位管理； ③.仪器传输参数设置； ④.人员档案管理； ⑤.样品登记管理； ⑥.委托客户资料管理； ⑦.人工报告检测数据输入； ⑧.检测报告打印发放； ⑨.实验室资质、设备、人员等证件资料管理模块； ⑩.其他二次开发的（用户要求）特殊功能模块。
构建实验室信息管理系统：LIMS技术与实践
最新发布
weixin_42466723的博客
09-13 1374
本文还有配套的精品资源，点击获取 简介：实验室信息管理系统（LIMS）是一种专业软件，旨在管理和优化实验室操作流程。LIMS整合样本管理、实验流程自动化、数据集成与管理、报告生成与分发、合规性支持、权限控制、资源调度及仪表板等多种功能，显著提高工作效率和数据质量。技术上，LIMS利用Web应用架构、JavaScript、前端框架和服务器端技术，配合关系型数据库系统，为实验室...
什么是实验室信息管理系统？
zmm201453的博客
09-06 1779
实验室信息管理系统（以下简称LIS系统）是医院信息化管理的重要组成部分，是结合临床检验科日常工作的需求，按检验科的工作流程设计，使检验有关各部门分散的业务连成一个共同整体，集分析检测、质量控制和检验科综合管理于一体的模块化、开放化的信息平台，是实现仪器检测与医疗信息自动化、智能化的检验科管理软件系统。检验科的检测仪器设备种类繁多，包括生化、常规、免疫等项目，仪器设备的功能和接口存在不统一的情况，要将计算机与仪器设备联机，实现检验结果的自动检测和存储，必须使用统一的国际标准接口才能解决问题。
实验室管理系统ssh框架
03-31
登陆页面：localhost:8080/Laboratory/login_login.do 调试：JDK 1.8 + Tomcat 8.5 + MySQL 5.7 用户：管理员、教师、学生 功能： 管理员：通知管理模块、预约和借用记录管理模块、实验室管理模块、设备信息管 理模块、用户管理模块、设备维修管理端、设备数据统计模块 教师：实验室预约、实验设备借用、个人信息管理 学生：实验设备借用、个人信息管理
实验室管理系统
qq_61141142的博客
12-13 315
目录1 绪论 1.1 开发背景 1.2 系统功能 1.3 系统可行性分析 1.4 开发工具 1.4.1 Visual studio.NET 2005 1.4.2 SQL Server 2000 1.5 开发语言 1.6 开发思想 2 需求分析 2.1 系统的功能结构图 2.2 系统的性能需求 2.3 系统的数据需求 2.4 系统的运行要求 3总体设计 4 详细设计 4.1 数据库设计 4.1.1 概念结构设计 4.1.2 逻辑结构设计 4.2 关键模块设计 4.2.1 学生功能模块 4.2.2 教师功能模块
管理信息系统框架
shenjianbi的博客
06-28 1130
在移动端APP风靡的今天，传统PC端是否没有发展前途呢。最近我用了一个很古老的语言（object pascal），写了一套PC端的三层架构，希望会有更多的人来关注传统PC端的应用程序的发展。个人觉得只要用心做，传统PC端的应用程序也会做得很好看。QQ群：管理信息系统，814480650。...
PHP版LIMS（开放实验室信息管理系统）
08-08
LIMS，全称为Laboratory Information Management System，即实验室信息管理系统，主要用于实验室数据的采集、管理、分析以及报告等各个环节，提高实验室的工作效率和数据准确性。在本文中，我们将深入探讨一个由外籍...
实验室实验和信息管理系统(LIMS)(最全97页).pptx
07-07
### 实验室实验和信息管理系统(LIMS)知识点详解 #### 一、系统概述 ##### 总体概述 实验室智能管理平台系统（LEIMS）旨在构建一个以学校实验室实验流程及信息管理为核心的综合管理平台。其核心目标是确保实验过程...
高校实验室设备管理系统（数据库）
03-17
高校实验室设备管理系统是一款基于SQL Server构建的信息管理工具，旨在提高实验室设备管理的效率和准确性，减少人为错误，实现实验室管理的信息化。系统的设计与开发涵盖了管理信息系统与数据库系统的理论知识，充分...
信息管理系统开发MVC框架源码
08-03
一、源码描述 这是一款采用了ext.net+ibatis.net+spring.net(接管controller)技术搭建的开发框架，代码干净，已包含基础的系统功能模块。 可以快速上手开发企业的信息管理系统，也可提供oracle 11g版本框架非常适合二次开发人员使用， 强烈推荐一下，感兴趣的欢迎下载看看啊。 二、框架简介 1、数据持久层使用IBatis.Net ORM 映射框架, 提供了较为灵活数据访问和面向对象特性。 2、界面层使用ext.net，Ext.NET是基于跨浏览器的ExtJS库和.NET Framework的一套支持 ASP.NET AJAX的Web控件，包含有丰富的Ajax运用所提供的界面已涉及界面大部分功能实现。 3、业务逻辑层使用模板方法+泛型，只需继承SessionHelper或MDSessionHelper 即可。 三、功能介绍 1、机构部门维护：提供企业部门信息新增、修改、删除等管理功能。 2、用户信息维护：维护企业各部门的人员信息。 3、角色信息维护：维护系统操作的角色。 4、系统功能定义：定义系统功能，动态加载系统功能。 5、角色权限分配：分配各角色所涉及的功能。 6、用户角色分配：维护相关用户的使用角色。 7、登录日志维护：维护并查看用户日志。 8、参数分类维护：维护企业必需的。 9、参数参数维护：维护参数类型下具体的参数。
实验室信息管理系统.zip
03-04
《实验室信息管理系统——人工智能在系统设计与开发中的实践》 实验室信息管理系统（LIMS，Laboratory Information Management System）是现代科研机构中不可或缺的工具，它整合了数据管理、实验流程控制、资源调度...
什么是实验室信息管理
qq_42709233的博客
12-31 366
实验室信息管理系统（LIMS）是将以数据库为核心的信息化技术与实验室管理需求相结合的信息化管理工具。以ISO/IEC17025:2017 CNAS-CL01《检测和校准实验室能力的通用要求》（国标为GB/T 27025:2019）规范为基础，结合网络化技术，将实验室的业务流程和设备资源以及行政管理等以合理方式进行管理。 实验室管理系统King'sLIMS是套完整的检验综合管理和产品质量监控体系，满足日常管理要求保证化验分析数据的严格管理和控制，集成了样品管理、资源管理、检验管理、数据管理、报表管理、质量体
java学生信息管理系统MVC架构
简简简简abc
03-12 3871
一、项目结构 二、源码 1.1、Student 类 /* * @FileName: Student.class * @version:1.0 * @author:nazi * 描述：模型层 * */ import java.io.Serializable; /* * Summary: Student类实现序列化接口，用于对象的保存 * @author：nazi *
LIMS实验室系统的结构分析
pubiaosoft的博客
07-18 770
LIMS实验室系统同其他领域的信息管理系统一样，伴随着计算机硬件、软件和网络技术等的发展而不断推陈出新，从20世纪60年开始，历经起源、发展、商品化三个阶段，LIMS实验室系统的结构也经历了三个主要发展阶段： 1）集中式结构 20世界60年代末至80年代的LIMS都属于此类结构。这类LIMS采用IBM大型机或者DEC超小型机为中央主机，星形网络拓扑结构，通过RS232连接多台终端或者通过DEC小型机采集仪器数据。这一时期的LIMS的主要功能有：仪器控制、数据采集和处理、结果的打印和输出。 2）两层结构：
信息管理系统——项目简介和系统架构
实践求真知
10-21 2702
一系统功能介绍 系统包括：用户管理，菜单管理和角色管理。 用户管理：添加用户 、查询用户、删除用户、修改用户、激活用户、冻结用户。 角色管理：添加角色、删除角色、修改角色、绑定用户、绑定用户操作。 菜单管理：添加菜单，删除菜单，修改菜单，查询下级菜单。 二相关技术 1传统表现层技术：JSP 2MVC框架：使用SpringMVC作为MVC框架。 3S...
信息系统安全管理架构
热门推荐
xsr的专栏
04-19 1万+
 建立我院信息安全管理体系构架 随着我院生产技术平台完全建立在网络之上和信息化建设的逐步升级，从整体上说已经开始将自己的日常业务完全转移到电子平台上，由此导致的“网络依赖性”已经使得我院的企业级网络信息安全成为全院关注的焦点，这其中最为显著的标志，就是从去年开始陡然增多的网络黑客的恶性破坏和、尼姆达病毒侵害事件和服务器崩溃事件等。众所周知，在信息高速发展的今天，我院CAD集成应用软件和
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值