main
YYQ 3 months ago
parent d03da57f92
commit 527345a864

@ -0,0 +1,5 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="WEB_MODULE" version="4">
<component name="NewModuleRootManager">
<content url="file://$MODULE_DIR$">
<excludeFolder url="file://$MODULE_DIR$/.tmp" />
<excludeFolder url="file://$MODULE_DIR$/temp" />
<excludeFolder url="file://$MODULE_DIR$/tmp" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

@ -0,0 +1,10 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
<option name="processCode" value="true" />
<option name="processLiterals" value="true" />
<option name="processComments" value="true" />
</inspection_tool>
</profile>
</component>

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="JavaScriptSettings">
<option name="languageLevel" value="ES6" />
</component>
</project>

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/front.iml" filepath="$PROJECT_DIR$/.idea/front.iml" />
</modules>
</component>
</project>

@ -0,0 +1,4 @@
{
"code": 1,
"msg": "服务端清理缓存成功"
}

@ -0,0 +1,234 @@
[
{
"title": "常规管理",
"icon": "fa fa-address-book",
"href": "",
"target": "_self",
"child": [
{
"title": "主页模板",
"href": "",
"icon": "fa fa-home",
"target": "_self",
"child": [
{
"title": "主页一",
"href": "page/welcome-1.html",
"icon": "fa fa-tachometer",
"target": "_self"
},
{
"title": "主页二",
"href": "page/welcome-2.html",
"icon": "fa fa-tachometer",
"target": "_self"
},
{
"title": "主页三",
"href": "page/welcome-3.html",
"icon": "fa fa-tachometer",
"target": "_self"
}
]
},
{
"title": "菜单管理",
"href": "page/menu.html",
"icon": "fa fa-window-maximize",
"target": "_self"
},
{
"title": "系统设置",
"href": "page/setting.html",
"icon": "fa fa-gears",
"target": "_self"
},
{
"title": "表格示例",
"href": "page/table.html",
"icon": "fa fa-file-text",
"target": "_self"
},
{
"title": "表单示例",
"href": "",
"icon": "fa fa-calendar",
"target": "_self",
"child": [
{
"title": "普通表单",
"href": "page/form.html",
"icon": "fa fa-list-alt",
"target": "_self"
},
{
"title": "分步表单",
"href": "page/form-step.html",
"icon": "fa fa-navicon",
"target": "_self"
}
]
},
{
"title": "登录模板",
"href": "",
"icon": "fa fa-flag-o",
"target": "_self",
"child": [
{
"title": "登录-1",
"href": "page/login-1.html",
"icon": "fa fa-stumbleupon-circle",
"target": "_blank"
},
{
"title": "登录-2",
"href": "page/login-2.html",
"icon": "fa fa-viacoin",
"target": "_blank"
},
{
"title": "登录-3",
"href": "page/login-3.html",
"icon": "fa fa-tags",
"target": "_blank"
}
]
},
{
"title": "异常页面",
"href": "",
"icon": "fa fa-home",
"target": "_self",
"child": [
{
"title": "404页面",
"href": "page/404.html",
"icon": "fa fa-hourglass-end",
"target": "_self"
}
]
},
{
"title": "其它界面",
"href": "",
"icon": "fa fa-snowflake-o",
"target": "",
"child": [
{
"title": "按钮示例",
"href": "page/button.html",
"icon": "fa fa-snowflake-o",
"target": "_self"
},
{
"title": "弹出层",
"href": "page/layer.html",
"icon": "fa fa-shield",
"target": "_self"
}
]
}
]
},
{
"title": "组件管理",
"icon": "fa fa-lemon-o",
"href": "",
"target": "_self",
"child": [
{
"title": "图标列表",
"href": "page/icon.html",
"icon": "fa fa-dot-circle-o",
"target": "_self"
},
{
"title": "图标选择",
"href": "page/icon-picker.html",
"icon": "fa fa-adn",
"target": "_self"
},
{
"title": "颜色选择",
"href": "page/color-select.html",
"icon": "fa fa-dashboard",
"target": "_self"
},
{
"title": "下拉选择",
"href": "page/table-select.html",
"icon": "fa fa-angle-double-down",
"target": "_self"
},
{
"title": "文件上传",
"href": "page/upload.html",
"icon": "fa fa-arrow-up",
"target": "_self"
},
{
"title": "富文本编辑器",
"href": "page/editor.html",
"icon": "fa fa-edit",
"target": "_self"
},
{
"title": "省市县区选择器",
"href": "page/area.html",
"icon": "fa fa-rocket",
"target": "_self"
}
]
},
{
"title": "其它管理",
"icon": "fa fa-slideshare",
"href": "",
"target": "_self",
"child": [
{
"title": "多级菜单",
"href": "",
"icon": "fa fa-meetup",
"target": "",
"child": [
{
"title": "按钮1",
"href": "page/button.html?v=1",
"icon": "fa fa-calendar",
"target": "_self",
"child": [
{
"title": "按钮2",
"href": "page/button.html?v=2",
"icon": "fa fa-snowflake-o",
"target": "_self",
"child": [
{
"title": "按钮3",
"href": "page/button.html?v=3",
"icon": "fa fa-snowflake-o",
"target": "_self"
},
{
"title": "表单4",
"href": "page/form.html?v=1",
"icon": "fa fa-calendar",
"target": "_self"
}
]
}
]
}
]
},
{
"title": "失效菜单",
"href": "page/error.html",
"icon": "fa fa-superpowers",
"target": "_self"
}
]
}
]

@ -0,0 +1,254 @@
{
"code": 0,
"msg": "",
"count": 19,
"data": [
{
"authorityId": 1,
"authorityName": "系统管理",
"orderNumber": 1,
"menuUrl": null,
"menuIcon": "layui-icon-set",
"createTime": "2018/06/29 11:05:41",
"authority": null,
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 0,
"parentId": -1
},
{
"authorityId": 2,
"authorityName": "用户管理",
"orderNumber": 2,
"menuUrl": "system/user",
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": null,
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 0,
"parentId": 1
},
{
"authorityId": 3,
"authorityName": "查询用户",
"orderNumber": 3,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/07/21 13:54:16",
"authority": "user:view",
"checked": 0,
"updateTime": "2018/07/21 13:54:16",
"isMenu": 1,
"parentId": 2
},
{
"authorityId": 4,
"authorityName": "添加用户",
"orderNumber": 4,
"menuUrl": null,
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": "user:add",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 2
},
{
"authorityId": 5,
"authorityName": "修改用户",
"orderNumber": 5,
"menuUrl": null,
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": "user:edit",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 2
},
{
"authorityId": 6,
"authorityName": "删除用户",
"orderNumber": 6,
"menuUrl": null,
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": "user:delete",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 2
},
{
"authorityId": 7,
"authorityName": "角色管理",
"orderNumber": 7,
"menuUrl": "system/role",
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": null,
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 0,
"parentId": 1
},
{
"authorityId": 8,
"authorityName": "查询角色",
"orderNumber": 8,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/07/21 13:54:59",
"authority": "role:view",
"checked": 0,
"updateTime": "2018/07/21 13:54:58",
"isMenu": 1,
"parentId": 7
},
{
"authorityId": 9,
"authorityName": "添加角色",
"orderNumber": 9,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/06/29 11:05:41",
"authority": "role:add",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 7
},
{
"authorityId": 10,
"authorityName": "修改角色",
"orderNumber": 10,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/06/29 11:05:41",
"authority": "role:edit",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 7
},
{
"authorityId": 11,
"authorityName": "删除角色",
"orderNumber": 11,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/06/29 11:05:41",
"authority": "role:delete",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 7
},
{
"authorityId": 12,
"authorityName": "角色权限管理",
"orderNumber": 12,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/06/29 11:05:41",
"authority": "role:auth",
"checked": 0,
"updateTime": "2018/07/13 15:27:18",
"isMenu": 1,
"parentId": 7
},
{
"authorityId": 13,
"authorityName": "权限管理",
"orderNumber": 13,
"menuUrl": "system/authorities",
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": null,
"checked": 0,
"updateTime": "2018/07/13 15:45:13",
"isMenu": 0,
"parentId": 1
},
{
"authorityId": 14,
"authorityName": "查询权限",
"orderNumber": 14,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/07/21 13:55:57",
"authority": "authorities:view",
"checked": 0,
"updateTime": "2018/07/21 13:55:56",
"isMenu": 1,
"parentId": 13
},
{
"authorityId": 15,
"authorityName": "添加权限",
"orderNumber": 15,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/06/29 11:05:41",
"authority": "authorities:add",
"checked": 0,
"updateTime": "2018/06/29 11:05:41",
"isMenu": 1,
"parentId": 13
},
{
"authorityId": 16,
"authorityName": "修改权限",
"orderNumber": 16,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/07/13 09:13:42",
"authority": "authorities:edit",
"checked": 0,
"updateTime": "2018/07/13 09:13:42",
"isMenu": 1,
"parentId": 13
},
{
"authorityId": 17,
"authorityName": "删除权限",
"orderNumber": 17,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/06/29 11:05:41",
"authority": "authorities:delete",
"checked": 0,
"updateTime": "2018/06/29 11:05:41",
"isMenu": 1,
"parentId": 13
},
{
"authorityId": 18,
"authorityName": "登录日志",
"orderNumber": 18,
"menuUrl": "system/loginRecord",
"menuIcon": null,
"createTime": "2018/06/29 11:05:41",
"authority": null,
"checked": 0,
"updateTime": "2018/06/29 11:05:41",
"isMenu": 0,
"parentId": 1
},
{
"authorityId": 19,
"authorityName": "查询登录日志",
"orderNumber": 19,
"menuUrl": "",
"menuIcon": "",
"createTime": "2018/07/21 13:56:43",
"authority": "loginRecord:view",
"checked": 0,
"updateTime": "2018/07/21 13:56:43",
"isMenu": 1,
"parentId": 18
}
]
}

@ -0,0 +1,127 @@
{
"code": 0,
"msg": "",
"count": 1000,
"data": [
{
"id": 10000,
"username": "user-0",
"sex": "女",
"city": "城市-0",
"sign": "签名-0",
"experience": 255,
"logins": 24,
"wealth": 82830700,
"classify": "作家",
"score": 57
},
{
"id": 10001,
"username": "user-1",
"sex": "男",
"city": "城市-1",
"sign": "签名-1",
"experience": 884,
"logins": 58,
"wealth": 64928690,
"classify": "词人",
"score": 27
},
{
"id": 10002,
"username": "user-2",
"sex": "女",
"city": "城市-2",
"sign": "签名-2",
"experience": 650,
"logins": 77,
"wealth": 6298078,
"classify": "酱油",
"score": 31
},
{
"id": 10003,
"username": "user-3",
"sex": "女",
"city": "城市-3",
"sign": "签名-3",
"experience": 362,
"logins": 157,
"wealth": 37117017,
"classify": "诗人",
"score": 68
},
{
"id": 10004,
"username": "user-4",
"sex": "男",
"city": "城市-4",
"sign": "签名-4",
"experience": 807,
"logins": 51,
"wealth": 76263262,
"classify": "作家",
"score": 6
},
{
"id": 10005,
"username": "user-5",
"sex": "女",
"city": "城市-5",
"sign": "签名-5",
"experience": 173,
"logins": 68,
"wealth": 60344147,
"classify": "作家",
"score": 87
},
{
"id": 10006,
"username": "user-6",
"sex": "女",
"city": "城市-6",
"sign": "签名-6",
"experience": 982,
"logins": 37,
"wealth": 57768166,
"classify": "作家",
"score": 34
},
{
"id": 10007,
"username": "user-7",
"sex": "男",
"city": "城市-7",
"sign": "签名-7",
"experience": 727,
"logins": 150,
"wealth": 82030578,
"classify": "作家",
"score": 28
},
{
"id": 10008,
"username": "user-8",
"sex": "男",
"city": "城市-8",
"sign": "签名-8",
"experience": 951,
"logins": 133,
"wealth": 16503371,
"classify": "词人",
"score": 14
},
{
"id": 10009,
"username": "user-9",
"sex": "女",
"city": "城市-9",
"sign": "签名-9",
"experience": 484,
"logins": 25,
"wealth": 86801934,
"classify": "词人",
"score": 75
}
]
}

@ -0,0 +1,23 @@
{
"code": 0,
"msg": "",
"count": 16,
"data": [
{ "id":"001", "username":"张玉林", "sex":"女" },
{ "id":"002", "username":"刘晓军", "sex":"男" },
{ "id":"003", "username":"张恒", "sex":"男" },
{ "id":"004", "username":"朱一", "sex":"男" },
{ "id":"005", "username":"刘佳能", "sex":"女" },
{ "id":"006", "username":"晓梅", "sex":"女" },
{ "id":"007", "username":"马冬梅", "sex":"女" },
{ "id":"008", "username":"刘晓庆", "sex":"女" },
{ "id":"009", "username":"刘晓庆", "sex":"女" },
{ "id":"010", "username":"刘晓庆", "sex":"女" },
{ "id":"011", "username":"刘晓庆", "sex":"女" },
{ "id":"012", "username":"刘晓庆", "sex":"女" },
{ "id":"013", "username":"刘晓庆", "sex":"女" },
{ "id":"014", "username":"刘晓庆", "sex":"女" },
{ "id":"015", "username":"刘晓庆", "sex":"女" },
{ "id":"016", "username":"刘晓庆", "sex":"女" }
]
}

@ -0,0 +1,10 @@
{
"code": 1,
"msg": "上传成功",
"data": {
"url": [
"../images/logo.png",
"../images/captcha.jpg"
]
}
}

@ -0,0 +1,803 @@
/**
*/
/**头部-配色*/
.layui-layout-admin .layui-header {
background-color: #1aa094 !important;
}
.layui-header > ul > .layui-nav-item.layui-this, .layuimini-tool i:hover {
background-color: #197971 !important;
}
.layui-header .layuimini-header-content > ul > .layui-nav-item.layui-this, .layuimini-tool i:hover {
background-color: #197971 !important;
}
/**logo-配色*/
.layui-layout-admin .layuimini-logo {
background-color: #243346 !important;
}
/**左侧-配色*/
.layui-side.layui-bg-black, .layui-side.layui-bg-black > .layuimini-menu-left > ul {
background-color: #2f4056 !important;
}
.layuimini-menu-left .layui-nav .layui-nav-child a:hover:not(.layui-this) {
background-color: #3b3f4b;
}
/**左侧菜单选中-配色*/
.layui-layout-admin .layui-nav-tree .layui-this, .layui-layout-admin .layui-nav-tree .layui-this > a, .layui-layout-admin .layui-nav-tree .layui-nav-child dd.layui-this, .layui-layout-admin .layui-nav-tree .layui-nav-child dd.layui-this a {
background-color: #1aa094 !important;
}
/**头部样式 */
.layui-layout-admin .header {
position: fixed;
left: 0;
right: 0;
top: 0;
bottom: 0;
}
.layuimini-header-menu, .layui-header {
height: 60px !important;
}
.layuimini-header-menu > .layui-nav-item {
color: #1b1d21;
height: 60px !important;
line-height: 60px !important;
}
.layui-header > .layui-layout-right > .layui-nav-item {
height: 60px !important;
line-height: 60px !important;
}
.layui-layout-left {
left: 295px !important;
}
.layui-nav.layui-layout-left.layuimini-header-menu.layuimini-pc-show {
font-weight: bold;
transition: all .2s;
}
/**logo演示通用 */
.layui-layout-admin .layuimini-logo {
font-weight: bold;
color: #ffffff !important;
height: 60px !important;
line-height: 60px !important;
overflow: hidden;
line-height: 64px;
transition: all .2s !important;
}
.layui-layout-admin .layuimini-logo img {
display: inline-block;
height: 40px;
vertical-align: middle;
}
.layui-layout-admin .layuimini-logo h1 {
display: inline-block;
margin: 0 0 0 12px;
color: #ffffff;
font-weight: 600;
font-size: 20px;
font-family: Avenir, Helvetica Neue, Arial, Helvetica, sans-serif;
vertical-align: middle;
}
/**缩放工具(通用) */
.layuimini-tool {
position: absolute !important;
top: 0;
left: 235px;
width: 60px;
height: 100%;
line-height: 60px;
text-align: center;
color: #ffffff !important;
transition: all .2s;
}
/**缩放工具(缩放) */
.layuimini-tool i {
display: block;
color: #bbe3df;
width: 32px;
height: 32px;
line-height: 32px;
border-radius: 3px;
text-align: center;
margin-top: 15px;
cursor: pointer;
}
.layuimini-page-header {
overflow: hidden;
display: block;
height: 35px;
line-height: 35px;
margin-bottom: 0;
border-radius: 0;
border-bottom: 1px solid #e1dddd;
}
.layuimini-page-header .layui-breadcrumb {
border-top: 1px solid #f6f6f6;
padding: 0 15px;
visibility: visible;
}
/**左侧菜单栏 (通用) */
.layui-side.layui-bg-black {
transition: all .2s;
}
.layui-side.layui-bg-black > .layuimini-menu-left > ul {
transition: all .2s;
}
.layui-side.layui-bg-black > .layuimini-menu-left > ul > .layui-nav-item:first-child {
border-top: 1px solid #4b5461;
}
.layuimini-menu-left .layui-nav .layui-nav-item a {
height: 40px;
line-height: 40px;
padding-right: 30px;
}
.layuimini-menu-left .layui-nav .layui-nav-item > a {
padding-top: 5px;
padding-bottom: 5px;
}
.layuimini-menu-left .layui-nav .layui-nav-child .layui-nav-child {
background: 0 0 !important
}
.layuimini-menu-left .layui-nav .layui-nav-more {
right: 15px;
}
.layuimini-menu-left .layui-nav .layui-nav-item a:hover {
background-color: transparent !important;
}
.layuimini-menu-left .layui-nav {
background-color: transparent !important;
}
/**左侧菜单栏 (正常) */
.layui-layout-body .layui-nav-itemed .layui-nav-child a, .layui-layout-body .layuimini-menu-left .layui-nav .layui-nav-child a {
padding-left: 35px;
}
.layui-layout-body .layuimini-menu-left .layui-nav .layui-nav-child .layui-nav-child a {
padding-left: 45px;
}
.layui-layout-body .layuimini-menu-left .layui-nav .layui-nav-child .layui-nav-child .layui-nav-child a {
padding-left: 55px;
}
.layui-layout-body .layuimini-menu-left .layui-nav .layui-nav-child .layui-nav-child .layui-nav-child .layui-nav-child a {
padding-left: 65px;
}
.layui-layout-body .layuimini-menu-left .layui-nav .layui-nav-itemed > .layui-nav-child {
padding: 5px 0;
}
/**内容主体(通用) */
.layui-layout-admin .layui-body {
/*position: fixed;*/
overflow: hidden;
bottom: 0px !important;
top: 60px !important;
transition: all .2s;
}
/**选择配色方案 */
.layuimini-color .color-title {
padding: 10px 0 10px 20px;
border-bottom: 1px solid #d9dada;
margin-bottom: 8px;
}
.layuimini-color .color-content {
padding: 10px 5px 0 5px;
}
.layuimini-color .color-content ul {
list-style: none;
text-align: center;
}
.layuimini-color .color-content ul li {
position: relative;
display: inline-block;
vertical-align: top;
width: 80px;
height: 50px;
margin: 0 15px 15px 0;
padding: 2px 2px 4px 2px;
background-color: #f2f2f2;
cursor: pointer;
font-size: 12px;
color: #666;
}
.layuimini-color .color-content li.layui-this:after, .layuimini-color .color-content li:hover:after {
width: 100%;
height: 100%;
padding: 4px;
top: -5px;
left: -5px;
border-color: #d8d8d8;
opacity: 1;
}
.layuimini-color .color-content li:after {
content: '';
position: absolute;
z-index: 20;
top: 50%;
left: 50%;
width: 1px;
height: 0;
border: 1px solid #f2f2f2;
transition: all .3s;
-webkit-transition: all .3s;
opacity: 0;
}
/**其它 */
.layui-tab-item {
width: 100% !important;
height: 100% !important;
}
.layui-nav-item.layui-this {
background-color: #1b1d21;
}
.layui-width-height {
width: 100%;
height: 95%;
}
.layui-tab {
margin: 0 0 0 0;
z-index: 99999;
}
.text-center {
height: 30px !important;
line-height: 30px !important;
text-align: center !important;
}
.layui-nav {
padding: 0 !important;
}
.layui-nav .layui-this:after, .layui-nav-bar, .layui-nav-tree .layui-nav-itemed:after {
width: 0 !important;
height: 0 !important;
}
.layui-layout-admin .layui-side {
top: 60px !important;
}
.layui-tab-card {
box-shadow: 0px 0px 0px #888888;
border-bottom: 0;
}
/*打开页面动画*/
.layui-tab-item.layui-show {
animation: moveTop 1s;
-webkit-animation: moveTop 1s;
animation-fill-mode: both;
-webkit-animation-fill-mode: both;
position: relative;
height: 100%;
-webkit-overflow-scrolling: touch;
overflow: auto;
}
@keyframes moveTop {
0% {
opacity: 0;
-webkit-transform: translateY(30px);
-ms-transform: translateY(30px);
transform: translateY(30px);
}
100% {
opacity: 1;
-webkit-transform: translateY(0);
-ms-transform: translateY(0);
transform: translateY(0);
}
}
@-o-keyframes moveTop {
0% {
opacity: 0;
-webkit-transform: translateY(30px);
-ms-transform: translateY(30px);
transform: translateY(30px);
}
100% {
opacity: 1;
-webkit-transform: translateY(0);
-ms-transform: translateY(0);
transform: translateY(0);
}
}
@-moz-keyframes moveTop {
0% {
opacity: 0;
-webkit-transform: translateY(30px);
-ms-transform: translateY(30px);
transform: translateY(30px);
}
100% {
opacity: 1;
-webkit-transform: translateY(0);
-ms-transform: translateY(0);
transform: translateY(0);
}
}
@-webkit-keyframes moveTop {
0% {
opacity: 0;
-webkit-transform: translateY(30px);
-ms-transform: translateY(30px);
transform: translateY(30px);
}
100% {
opacity: 1;
-webkit-transform: translateY(0);
-ms-transform: translateY(0);
transform: translateY(0);
}
}
/**自定义滚动条样式 */
::-webkit-scrollbar {
width: 6px;
height: 6px
}
::-webkit-scrollbar-track {
background-color: transparent;
-webkit-border-radius: 2em;
-moz-border-radius: 2em;
border-radius: 2em;
}
::-webkit-scrollbar-thumb {
background-color: #9c9da0;
-webkit-border-radius: 2em;
-moz-border-radius: 2em;
border-radius: 2em
}
.layuimini-content-page {
overflow: auto;
width: 100%;
height: 100%;
}
/*移动端遮罩层*/
.layuimini-make {
position: fixed;
left: 0;
right: 0;
bottom: 0;
top: 0;
z-index: 1000;
background: rgba(0, 0, 0, .5);
display: none;
}
.layuimini-mini .layui-header {
z-index: 1001;
}
/**初始化加载层*/
.layuimini-loader {
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
background-color: #ffffff;
z-index: 999999;
}
.layuimini-loader .layuimini-loader-inner {
display: block;
position: relative;
left: 50%;
top: 50%;
width: 150px;
height: 150px;
margin: -75px 0 0 -75px;
border-radius: 50%;
border: 3px solid transparent;
border-top-color: #1E9FFF;
animation: spin 2s linear infinite;
}
.layuimini-loader .layuimini-loader-inner:before {
content: "";
position: absolute;
top: 5px;
left: 5px;
right: 5px;
bottom: 5px;
border-radius: 50%;
border: 3px solid transparent;
border-top-color: #1E9FFF;
animation: spin 3s linear infinite;
}
.layuimini-loader .layuimini-loader-inner:after {
content: "";
position: absolute;
top: 15px;
left: 15px;
right: 15px;
bottom: 15px;
border-radius: 50%;
border: 3px solid transparent;
border-top-color: #1E9FFF;
animation: spin 1.5s linear infinite;
}
@keyframes spin {
0% {
transform: rotate(0deg);
}
to {
transform: rotate(1turn);
}
}
/*系统设置*/
.layuimini-color .layui-word-aux {
position: absolute;
left: 60px;
top: 12px;
font-size: 12px;
}
.layuimini-color .layui-input-block {
margin-left: 15px;
min-height: 36px;
}
.layuimini-color .more-menu-list {
width: 100%;
margin-top: 30px;
}
.layuimini-color .more-menu-item:first-child {
border-top: 1px solid #e8e8e8;
}
.layuimini-color .more-menu-item .layui-icon {
font-size: 18px;
padding-right: 10px;
}
.layuimini-color .more-menu-item {
color: #595959;
height: 50px;
line-height: 50px;
font-size: 16px;
padding: 0 25px;
border-bottom: 1px solid #e8e8e8;
font-style: normal;
display: block;
}
.layuimini-color .more-menu-item:hover {
background-color: whitesmoke;
}
.layuimini-color .more-menu-item:after {
color: #8c8c8c;
right: 16px;
content: "\e602";
position: absolute;
font-family: layui-icon !important;
}
/**
*/
.popup-tips .layui-layer-TipsG{
display: none;
}
.popup-tips.layui-layer-tips .layui-layer-content{
padding: 0;
}
.popup-tips .layui-nav-tree{
width: 150px;
border-radius: 10px;
}
/**左侧菜单字体间距*/
.layuimini-menu-left .layui-nav-item a span {
letter-spacing: 1px;
}
/**头部菜单字体间距*/
.layui-layout-admin .layui-header .layuimini-header-menu.layuimini-pc-show,.layui-layout-admin .layui-header .layuimini-header-menu.layuimini-mobile-show {
letter-spacing: 1px;
}
/**左侧菜单更多下拉样式*/
.layuimini-menu-left .layui-nav-more,.layuimini-menu-left-zoom .layui-nav-more {
font-family: layui-icon !important;
font-size: 12px;
font-style: normal;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
overflow: hidden;
width: auto;
height: auto;
line-height: normal;
border: none;
display: inline-block;
margin-top: -6px !important;
}
.layuimini-menu-left .layui-nav-child .layui-nav-more {
margin-top: -6px !important;
}
.layuimini-menu-left .layui-nav .layui-nav-mored,.layuimini-menu-left .layui-nav-itemed>a .layui-nav-more{
margin-top: -9px!important;
}
.layuimini-menu-left-zoom.layui-nav .layui-nav-mored,.layuimini-menu-left-zoom.layui-nav-itemed>a .layui-nav-more{
margin-top: -9px!important;
}
.layuimini-menu-left .layui-nav-more:before,.layuimini-menu-left-zoom .layui-nav-more:before {
content: "\e61a";
}
.layuimini-menu-left .layui-nav-itemed > a > .layui-nav-more,.layuimini-menu-left-zoom .layui-nav-itemed > a > .layui-nav-more {
transform: rotate(180deg);
-ms-transform: rotate(180deg);
-moz-transform: rotate(180deg);
-webkit-transform: rotate(180deg);
-o-transform: rotate(180deg);
width: 12px;
text-align: center;
border-style:none;
}
.layuimini-menu-left .layui-nav-itemed > a > .layui-nav-more:before,.layuimini-menu-left-zoom .layui-nav-itemed > a > .layui-nav-more:before {
content: '\e61a';
background-color: transparent;
display: inline-block;
vertical-align: middle;
}
/**修复左侧菜单字体不对齐的问题*/
.layuimini-menu-left .layui-nav-item a .fa,.layuimini-menu-left .layui-nav-item a .layui-icon{
width: 20px;
}
/**
PC
*/
@media screen and (min-width: 1025px) {
/**头部样式(缩放) */
.layuimini-mini .layui-layout-left.layuimini-header-menu.layuimini-pc-show {
left: 155px !important;
}
/**logo演示缩放 */
.layuimini-mini .layui-layout-admin .layuimini-logo {
width: 60px !important;
}
.layuimini-mini .layui-layout-admin .layuimini-logo h1 {
display: none;
}
/**左侧菜单栏(缩放) */
.layuimini-mini .layuimini-menu-left {
width: 80px !important;
}
.layuimini-mini .layui-side.layui-bg-black, .layuimini-mini .layuimini-menu-left > ul, .layuimini-mini .layuimini-menu-left > ul li i {
width: 60px !important;
}
.layuimini-mini .layuimini-menu-left > ul li span:first-child {
display: none;
}
.layuimini-mini .layuimini-menu-left > ul li span:last-child {
float: right;
right: 7px;
}
.layuimini-mini .layuimini-menu-left .layui-nav .layui-nav-item a {
height: 40px;
line-height: 40px;
padding-right: 0px !important;
}
/**内容主体(缩放) */
.layuimini-mini .layui-layout-admin .layui-body {
left: 60px !important;
}
.layuimini-mini .layuimini-tool {
left: 95px !important;
}
.layuimini-pc-show{
display: block;
}
.layuimini-mobile-show{
display: none;
}
/**菜单缩放*/
.layuimini-mini .layuimini-menu-left .layui-nav-more,.layuimini-mini .layuimini-menu-left .layui-nav-child{
display: none!important;
}
}
/**
*/
@media screen and (max-width: 1024px) {
.layuimini-pc-show{
display: none;
}
.layuimini-mobile-show{
display: block;
}
.layuimini-header-content {
left: 0;
}
.layui-layout-admin .layui-body .layui-tab-item.layui-show {
border-top: 1px solid #e2e2e2;
}
.layuimini-all .layui-layout-left.layuimini-header-menu {
left: 15px !important
}
.layuimini-mini .layui-layout-left.layuimini-header-menu {
left: 205px !important
}
.layui-layout-admin .layui-nav.layui-layout-right > li:not(.layuimini-setting) {
width: 40px !important;
}
.layui-layout-admin .layui-nav.layui-layout-right > li:not(.layuimini-setting) a {
padding: 0 15px;
}
.layuimini-all .layui-layout-admin .layui-body {
left: 0px !important;
}
.layuimini-mini .layui-layout-admin .layuimini-menu-left, .layuimini-mini .layui-header .layuimini-logo {
left: 0;
transition: left .2s;
z-index: 1001 !important;
}
.layuimini-all .layui-layout-admin .layuimini-menu-left, .layuimini-all .layui-header .layuimini-logo {
left: -200px;
transition: left .2s;
top: 0;
z-index: 1002;
}
.layuimini-mini .layui-layout-admin .layui-body {
left: 0!important;
transition: left .2s;
top: 0;
z-index: 998;
}
.layuimini-mini .layuimini-make {
display: block;
}
.layuimini-multi-module .layuimini-header-content .layuimini-tool {
display: none;
}
.layuimini-single-module .layuimini-header-content .layuimini-tool {
left: 15px;
}
.layuimini-mini .layuimini-site-mobile {
display: none !important;
}
.layuimini-site-mobile {
display: block !important;
position: fixed;
z-index: 100000;
bottom: 15px;
left: 15px;
width: 40px;
height: 40px;
line-height: 40px;
border-radius: 2px;
text-align: center;
background-color: rgba(0, 0, 0, .7);
color: #fff;
}
.layuimini-header-content {
z-index: 997;
}
.layuimini-content-page {
-webkit-overflow-scrolling: touch;
}
/*修复UC之类的浏览器点击无效*/
.layuimini-make {
cursor: pointer;
}
.layuimini-site-mobile {
cursor: pointer;
}
}
@media screen and (max-width: 550px){
/**头部右侧数据*/
.layuimini-multi-module.layuimini-mini .layuimini-header-content .layui-layout-right {
display: none;
}
}

@ -0,0 +1,13 @@
.layuimini-content-page{background-color:#f2f2f2!important;}
.layuimini-container {border:1px solid #f2f2f2;border-radius:5px;background-color:#f2f2f2}
.layuimini-main {margin:10px 10px 10px 10px;border:5px solid #ffffff;border-radius:5px;background-color:#ffffff}
.layui-breadcrumb>* {font-size: 13px;!important;}
/**必填红点 */
.layuimini-form>.layui-form-item>.required:after {content:'*';color:red;position:absolute;margin-left:4px;font-weight:bold;line-height:1.8em;top:6px;right:5px;}
.layuimini-form>.layui-form-item>.layui-form-label {width:120px !important;}
.layuimini-form>.layui-form-item>.layui-input-block {margin-left:150px !important;}
.layuimini-form>.layui-form-item>.layui-input-block >tip {display:inline-block;margin-top:10px;line-height:10px;font-size:10px;color:#a29c9c;}
/**搜索框*/
.layuimini-container .table-search-fieldset {margin: 0;border: 1px solid #e6e6e6;padding: 10px 20px 5px 20px;color: #6b6b6b;}

@ -0,0 +1,95 @@
/*头部右侧背景色 headerRightBg */
.layui-layout-admin .layui-header {
background-color: #ffffff !important;
}
/*头部右侧选中背景色 headerRightBgThis */
.layui-layout-admin .layui-header .layuimini-header-content > ul > .layui-nav-item.layui-this, .layuimini-tool i:hover {
background-color: #e4e4e4 !important;
}
/*头部右侧字体颜色 headerRightColor */
.layui-layout-admin .layui-header .layui-nav .layui-nav-item a {
color: rgba(107, 107, 107, 0.7);
}
/**头部右侧下拉字体颜色 headerRightChildColor */
.layui-layout-admin .layui-header .layui-nav .layui-nav-item .layui-nav-child a {
color: rgba(107, 107, 107, 0.7) !important;
}
/*头部右侧鼠标选中 headerRightColorThis */
.layui-header .layuimini-menu-header-pc.layui-nav .layui-nav-item a:hover, .layui-header .layuimini-header-menu.layuimini-pc-show.layui-nav .layui-this a {
color: #565656 !important;
}
/*头部右侧更多下拉颜色 headerRightNavMore */
.layui-header .layui-nav .layui-nav-more {
border-top-color: rgba(160, 160, 160, 0.7) !important;
}
/*头部右侧更多下拉颜色 headerRightNavMore */
.layui-header .layui-nav .layui-nav-mored, .layui-header .layui-nav-itemed > a .layui-nav-more {
border-color: transparent transparent rgba(160, 160, 160, 0.7) !important;
}
/**头部右侧更多下拉配置色 headerRightNavMoreBg headerRightNavMoreColor */
.layui-header .layui-nav .layui-nav-child dd.layui-this a, .layui-header .layui-nav-child dd.layui-this, .layui-layout-admin .layui-header .layui-nav .layui-nav-item .layui-nav-child .layui-this a {
background-color: #1E9FFF !important;
color: #ffffff !important;
}
/*头部缩放按钮样式 headerRightToolColor */
.layui-layout-admin .layui-header .layuimini-tool i {
color: #565656;
}
/*logo背景颜色 headerLogoBg */
.layui-layout-admin .layuimini-logo {
background-color: #192027 !important;
}
/*logo字体颜色 headerLogoColor */
.layui-layout-admin .layuimini-logo h1 {
color: rgb(191, 187, 187);
}
/*左侧菜单更多下拉样式 leftMenuNavMore */
.layuimini-menu-left .layui-nav .layui-nav-more, .layuimini-menu-left-zoom.layui-nav .layui-nav-more {
border-top-color: rgb(191, 187, 187);
}
/*左侧菜单更多下拉样式 leftMenuNavMore */
.layuimini-menu-left .layui-nav .layui-nav-mored, .layuimini-menu-left .layui-nav-itemed > a .layui-nav-more, .layuimini-menu-left-zoom.layui-nav .layui-nav-mored, .layuimini-menu-left-zoom.layui-nav-itemed > a .layui-nav-more {
border-color: transparent transparent rgb(191, 187, 187) !important;
}
/*左侧菜单背景 leftMenuBg */
.layui-side.layui-bg-black, .layui-side.layui-bg-black > .layuimini-menu-left > ul, .layuimini-menu-left-zoom > ul {
background-color: #28333E !important;
}
/*左侧菜单选中背景 leftMenuBgThis */
.layuimini-menu-left .layui-nav-tree .layui-this, .layuimini-menu-left .layui-nav-tree .layui-this > a, .layuimini-menu-left .layui-nav-tree .layui-nav-child dd.layui-this, .layuimini-menu-left .layui-nav-tree .layui-nav-child dd.layui-this a, .layuimini-menu-left-zoom.layui-nav-tree .layui-this, .layuimini-menu-left-zoom.layui-nav-tree .layui-this > a, .layuimini-menu-left-zoom.layui-nav-tree .layui-nav-child dd.layui-this, .layuimini-menu-left-zoom.layui-nav-tree .layui-nav-child dd.layui-this a {
background-color: #1E9FFF !important
}
/*左侧菜单子菜单背景 leftMenuChildBg */
.layuimini-menu-left .layui-nav-itemed > .layui-nav-child {
background-color: #0c0f13 !important;
}
/*左侧菜单字体颜色 leftMenuColor */
.layuimini-menu-left .layui-nav .layui-nav-item a, .layuimini-menu-left-zoom.layui-nav .layui-nav-item a {
color: rgb(191, 187, 187) !important;
}
/*左侧菜单选中字体颜色 leftMenuColorThis */
.layuimini-menu-left .layui-nav .layui-nav-item a:hover, .layuimini-menu-left .layui-nav .layui-this a, .layuimini-menu-left-zoom.layui-nav .layui-nav-item a:hover, .layuimini-menu-left-zoom.layui-nav .layui-this a {
color: #ffffff !important;
}
/**tab选项卡选中颜色 tabActiveColor */
.layuimini-tab .layui-tab-title .layui-this .layuimini-tab-active {
background-color: #1e9fff;
}

@ -0,0 +1,47 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form">
<div class="layui-form-item">
<label class="layui-form-label required">名称</label>
<div class="layui-input-block">
<input type="text" name="name" lay-verify="required" lay-reqtext="名称不能为空" placeholder="请输入名称" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios'], function () {
let form = layui.form,
layer = layui.layer,
axios = layui.axios,
$ = layui.$;
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
form.render();
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
//监听提交
form.on('submit(saveBtn)', function (data) {
axios.post('grade/create',data.field).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,149 @@
<div class="layuimini-container layuimini-page-anim">
<div class="layuimini-main">
<div style="margin: 10px 10px 10px 10px">
<form class="layui-form layui-form-pane" action="">
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">名称</label>
<div class="layui-input-inline">
<input type="text" name="name" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-inline">
<button type="submit" class="layui-btn layui-btn-primary" lay-submit lay-filter="data-search-btn"><i class="layui-icon"></i> 搜 索</button>
</div>
</div>
</form>
</div>
<script type="text/html" id="toolbarDemo">
<div class="layui-btn-container">
<button class="layui-btn layui-btn-normal layui-btn-sm data-add-btn" lay-event="add">
<i class="layui-icon layui-icon-add-circle"></i>
新增
</button>
<button class="layui-btn layui-btn-sm layui-btn-normal data-delete-btn" lay-event="update">
<i class="layui-icon layui-icon-edit"></i>
修改
</button>
<button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn" lay-event="delete">
<i class="layui-icon layui-icon-delete"></i>
删除
</button>
</div>
</script>
<table class="layui-hide" id="currentTableId" lay-filter="currentTableFilter"></table>
</div>
</div>
<script>
layui.use(['form', 'table','miniPage','form','element','axios'], function () {
let $ = layui.jquery,
form = layui.form,
table = layui.table,
axios = layui.axios,
miniPage = layui.miniPage;
table.render({
elem: '#currentTableId',
method:'post',
url: 'grade/query',
toolbar: '#toolbarDemo',
defaultToolbar: ['filter', 'exports', 'print'],
cols: [[
{type: "checkbox", width: 50},
{field: 'id', width: 80, title: 'ID'},
{field: 'name',title: '名称'}
]],
page: true,
skin: 'line'
});
window.reload = function(){
table.reload('currentTableId');
}
// 监听搜索操作
form.on('submit(data-search-btn)', function (data) {
let result = JSON.stringify(data.field);
//执行搜索重载
table.reload('currentTableId', {
where: data.field
}, 'data');
return false;
});
/**
* toolbar事件监听
*/
table.on('toolbar(currentTableFilter)', function (obj) {
if (obj.event === 'add') { // 监听添加操作
let content = miniPage.getHrefContent('grade/add.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
$(window).on("resize", function () {
layer.full(index);
});
} else if (obj.event === 'update') { //修改操作
let data = table.checkStatus('currentTableId').data;
if(data.length!=1){
layer.msg("请选择一条记录修改");
}else{
let content = miniPage.getHrefContent('grade/update.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
setFormValue(data[0]);
$(window).on("resize", function () {
layer.full(index);
});
}
}else if (obj.event === 'delete') { //删除操作
let data = table.checkStatus('currentTableId').data;
if(data.length==0){
layer.msg("请选择要删除的数据");
}else{
layer.confirm('真的删除行吗', function (index) {
//异步删除 map\filter\some\every
let arr = data.map(item=>item.id);
axios.get('grade/delete?ids='+arr.join(",")).then(function (response) {
table.reload('currentTableId');
layer.msg(response.msg);
}).catch(function (error) {
layer.msg(error);
});
layer.close(index);
});
}
}
});
function setFormValue(data){
form.val("updateForm",{
id:data.id,
name:data.name,
})
}
});
</script>

@ -0,0 +1,50 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form" lay-filter="updateForm">
<div class="layui-form-item">
<input type="hidden" name="id">
<label class="layui-form-label required">名称</label>
<div class="layui-input-block">
<input type="text" name="name" lay-verify="required" lay-reqtext="名称不能为空" placeholder="请输入名称" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios'], function () {
let form = layui.form,
layer = layui.layer,
axios = layui.axios,
$ = layui.$;
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
form.render();
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
//监听提交
form.on('submit(saveBtn)', function (data) {
axios.post('grade/update',data.field).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,90 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form">
<div class="layui-form-item">
<label class="layui-form-label required">标题</label>
<div class="layui-input-block">
<input type="text" name="title" id="title" lay-verify="required" lay-reqtext="标题不能为空" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">内容</label>
<div class="layui-input-block">
<textarea placeholder="请输入内容" name="content" id="content" class="layui-textarea"></textarea>
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">接收范围</label>
<div class="layui-input-block building-add">
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios','ztree','laydate'], function () {
let form = layui.form,
layer = layui.layer,
ztree = layui.ztree,
laydate = layui.laydate,
axios = layui.axios,
$ = layui.$;
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
//日期
laydate.render({
elem: '#visitTime'
});
laydate.render({
elem: '#leaveTime'
});
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
axios.post('building/query',{}).then(function (response) {
response.data.forEach(item=>{
let option = `<input type="checkbox" lay-skin="primary" name="buildingId" value="${item.id}">${item.name}<br/>`
$('.building-add').append(option);
})
form.render();
});
//监听提交
form.on('submit(saveBtn)', function (data) {
console.log(data.field);
let param = {};
param.title = data.field.title;
param.content = data.field.content;
let arr = $('.building-add input[type="checkbox"]');
let buildingIdArr = [];
for(let i=0;i<arr.length;i++){
if(arr[i].checked){
buildingIdArr.push(arr[i].value)
}
}
param.buildingIds = buildingIdArr;
axios.post('notice/create',param).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,155 @@
<div class="layuimini-container layuimini-page-anim">
<div class="layuimini-main">
<div style="margin: 10px 10px 10px 10px">
<form class="layui-form layui-form-pane" action="">
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">标题</label>
<div class="layui-input-inline">
<input type="text" name="title" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-inline">
<button type="submit" class="layui-btn layui-btn-primary" lay-submit lay-filter="data-search-btn"><i class="layui-icon"></i> 搜 索</button>
</div>
</div>
</form>
</div>
<script type="text/html" id="toolbarDemo">
<div class="layui-btn-container">
<button class="layui-btn layui-btn-normal layui-btn-sm data-add-btn" lay-event="add">
<i class="layui-icon layui-icon-add-circle"></i>
新增
</button>
<button class="layui-btn layui-btn-sm layui-btn-normal data-delete-btn" lay-event="update">
<i class="layui-icon layui-icon-edit"></i>
修改
</button>
<button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn" lay-event="delete">
<i class="layui-icon layui-icon-delete"></i>
删除
</button>
</div>
</script>
<table class="layui-hide" id="currentTableId" lay-filter="currentTableFilter"></table>
</div>
</div>
<script>
layui.use(['form', 'table','miniPage','miniAdmin','form','element','axios'], function () {
var $ = layui.jquery,
form = layui.form,
table = layui.table,
axios = layui.axios,
form = layui.form,
miniAdmin = layui.miniAdmin,
miniPage = layui.miniPage;
table.render({
elem: '#currentTableId',
method:'post',
url: 'notice/query',
toolbar: '#toolbarDemo',
defaultToolbar: ['filter', 'exports', 'print'],
cols: [[
{type: "checkbox", width: 50},
{field: 'id', width: 80, title: 'ID'},
{field: 'title',title: '标题'},
{field: 'userId',title: '发布者',templet:'<div>{{d.user.name}}</div>'},
{field: 'createTime',title: '发布时间'},
]],
page: true,
skin: 'line'
});
window.reload = function(){
table.reload('currentTableId');
}
// 监听搜索操作
form.on('submit(data-search-btn)', function (data) {
var result = JSON.stringify(data.field);
//执行搜索重载
table.reload('currentTableId', {
where: data.field
}, 'data');
return false;
});
/**
* toolbar事件监听
*/
table.on('toolbar(currentTableFilter)', function (obj) {
if (obj.event === 'add') { // 监听添加操作
let content = miniPage.getHrefContent('notice/add.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
$(window).on("resize", function () {
layer.full(index);
});
} else if (obj.event === 'update') { //修改操作
let data = table.checkStatus('currentTableId').data;
if(data.length!=1){
layer.msg("请选择一条记录修改");
}else{
let content = miniPage.getHrefContent('notice/update.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
setFormValue(data[0]);
$(window).on("resize", function () {
layer.full(index);
});
}
}else if (obj.event === 'delete') { //删除操作
let data = table.checkStatus('currentTableId').data;
if(data.length==0){
layer.msg("请选择要删除的数据");
}else{
layer.confirm('真的删除行吗', function (index) {
//异步删除 map\filter\some\every
let arr = data.map(item=>item.id);
axios.get('notice/delete?ids='+arr.join(",")).then(function (response) {
table.reload('currentTableId');
layer.msg(response.msg);
}).catch(function (error) {
layer.msg(error);
});
layer.close(index);
});
}
}
});
function setFormValue(data){
form.val("updateForm",{
id:data.id,
title:data.title,
content:data.content,
})
}
});
</script>

@ -0,0 +1,107 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form" lay-filter="updateForm">
<div class="layui-form-item">
<label class="layui-form-label required">标题</label>
<div class="layui-input-block">
<input type="hidden" name="id" id="id">
<input type="text" name="title" id="title" lay-verify="required" lay-reqtext="标题不能为空" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">内容</label>
<div class="layui-input-block">
<textarea placeholder="请输入内容" name="content" id="content" class="layui-textarea"></textarea>
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">接收范围</label>
<div class="layui-input-block building-update">
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios','ztree','laydate'], function () {
let form = layui.form,
layer = layui.layer,
ztree = layui.ztree,
laydate = layui.laydate,
axios = layui.axios,
$ = layui.$;
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
//日期
laydate.render({
elem: '#visitTime'
});
laydate.render({
elem: '#leaveTime'
});
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
function loadReceive(){
return axios.post('noticeReceive/query',{noticeId:$('#id').val()});
}
function loadBuilding(){
return axios.post('building/query',{});
}
axios.all([loadReceive(), loadBuilding()]).then(axios.spread(function (response, response2) {
let arr = response.data.map(item=>item.buildingId);
response2.data.forEach(item=>{
let option;
if(arr.some(val=>val == item.id)){
option = `<input type="checkbox" checked lay-skin="primary" name="buildingId" value="${item.id}">${item.name}<br/>`
}else{
option = `<input type="checkbox" lay-skin="primary" name="buildingId" value="${item.id}">${item.name}<br/>`
}
$('.building-update').append(option);
})
form.render();
}));
//监听提交
form.on('submit(saveBtn)', function (data) {
let param = {};
param.id = data.field.id;
param.title = data.field.title;
param.content = data.field.content;
let arr = $('.building-update input[type="checkbox"]');
let buildingIdArr = [];
for(let i=0;i<arr.length;i++){
if(arr[i].checked){
buildingIdArr.push(arr[i].value)
}
}
param.buildingIds = buildingIdArr;
axios.post('notice/update',param).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,106 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form">
<div class="layui-form-item">
<label class="layui-form-label required">名称</label>
<div class="layui-input-block">
<input type="text" name="name" lay-verify="required" lay-reqtext="名称不能为空" placeholder="请输入名称" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">上级栏目</label>
<div class="layui-input-block">
<input type="hidden" name="parentId" id="parentId" placeholder="请选择上级栏目" value="" class="layui-input">
<input type="text" name="parentName" readonly id="parentName" placeholder="请选择上级栏目" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label" required>类型</label>
<div class="layui-input-block">
<select name="type" id="type" lay-verify="required">
<option value="">请选择类型</option>
<option value="1">学院</option>
<option value="2"></option>
<option value="3">专业</option>
<option value="4">班级</option>
</select>
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label" required>年级</label>
<div class="layui-input-block">
<select name="gradeId" id="gradeId" lay-verify="required">
</select>
</div>
</div>
<div class="layui-form-item layui-form-text">
<label class="layui-form-label">备注信息</label>
<div class="layui-input-block">
<textarea name="remark" class="layui-textarea" placeholder="请输入备注信息"></textarea>
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios','selectOrg'], function () {
let form = layui.form,
layer = layui.layer,
selectOrg = layui.selectOrg,
axios = layui.axios,
$ = layui.$;
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
form.render();
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
selectOrg.render({
elem:'#parentName',
selected:[],
checked:false,
done:function (data) {
$('#parentId').val(data[0].id);
$('#parentName').val(data[0].name);
}
});
axios.post('grade/query',{}).then(function (response) {
let options = '<option value="">请选择年级</option>';
for(let obj of response.data){
options+='<option value="'+obj.id+'">'+obj.name+'</option>'
}
console.log(options);
$('#gradeId').append(options);
form.render('select');
}).catch();
//监听提交
form.on('submit(saveBtn)', function (data) {
axios.post('org/create',data.field).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,124 @@
<div class="layuimini-container layuimini-page-anim">
<div class="layuimini-main">
<div class="layui-btn-container">
<button class="layui-btn layui-btn-normal layui-btn-sm data-add-btn" lay-event="add">
<i class="layui-icon layui-icon-add-circle"></i>
新增
</button>
<button class="layui-btn layui-btn-sm layui-btn-normal data-update-btn" lay-event="update">
<i class="layui-icon layui-icon-edit"></i>
修改
</button>
<button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn" lay-event="delete">
<i class="layui-icon layui-icon-delete"></i>
删除
</button>
</div>
<div class="ztree" id="ztree"></div>
<!--<input type="text" class="layui-input" id="demo">-->
</div>
</div>
<script>
layui.use(['form','miniPage','element','axios','ztree','selectOrg'], function () {
let $ = layui.jquery,
form = layui.form,
axios = layui.axios,
ztree = layui.ztree,
selectOrg = layui.selectOrg,
miniPage = layui.miniPage;
let setting = {
data: {
simpleData: {
enable: true
}
}
};
function loadTree(){
axios.get('org/tree').then(function (response) {
ztree.init($("#ztree"), setting,response.data);
}).catch(function (error) {
console.log(error);
});
}
loadTree();
window.reload = function(){
loadTree();
}
$('.data-add-btn').click(function () {
let content = miniPage.getHrefContent('org/add.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
$(window).on("resize", function () {
layer.full(index);
});
});
$('.data-update-btn').click(function () {
let content = miniPage.getHrefContent('org/update.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '修改',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
let treeObj = ztree.getZTreeObj("ztree");
let node = treeObj.getSelectedNodes()[0];
form.val('updateForm',{
id:node.id,
name:node.name,
parentId:node.pId,
})
$('#parentName').val(node.getParentNode().name)
$(window).on("resize", function () {
layer.full(index);
});
});
$('.data-delete-btn').click(function () {
let treeObj = ztree.getZTreeObj("ztree");
let node = treeObj.getSelectedNodes()[0];
if(node){
layer.confirm('真的删除行吗', function (index) {
axios.get('org/delete?id='+node.id).then(function (response) {
loadTree();
layer.msg(response.msg);
}).catch(function (error) {
layer.msg(error);
});
layer.close(index);
});
}else{
layer.msg("请选择要删除的数据");
}
});
});
</script>

@ -0,0 +1,109 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form" lay-filter="updateForm">
<div class="layui-form-item">
<label class="layui-form-label required">名称</label>
<div class="layui-input-block">
<input type="hidden" id="id" name="id">
<input type="text" name="name" lay-verify="required" lay-reqtext="名称不能为空" placeholder="请输入名称" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">上级栏目</label>
<div class="layui-input-block">
<input type="hidden" name="parentId" id="parentId" lay-verify="required" lay-reqtext="上级栏目不能为空" placeholder="请选择上级栏目" value="" class="layui-input">
<input type="text" name="parentName" readonly id="parentName" lay-verify="required" lay-reqtext="上级栏目不能为空" placeholder="请选择上级栏目" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label" required>类型</label>
<div class="layui-input-block">
<select name="type" id="type" lay-verify="required">
<option value="">请选择类型</option>
<option value="1">学院</option>
<option value="2"></option>
<option value="3">专业</option>
<option value="4">班级</option>
</select>
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label" required>年级</label>
<div class="layui-input-block">
<select name="gradeId" id="gradeId" lay-verify="required">
</select>
</div>
</div>
<div class="layui-form-item layui-form-text">
<label class="layui-form-label">备注信息</label>
<div class="layui-input-block">
<textarea name="remark" class="layui-textarea" placeholder="请输入备注信息"></textarea>
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios','selectOrg'], function () {
let form = layui.form,
layer = layui.layer,
selectOrg = layui.selectOrg,
axios = layui.axios,
$ = layui.$;
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
form.render();
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
selectOrg.render({
elem:'#parentName',
selected:[],
checked:false,
done:function (data) {
$('#parentId').val(data[0].id);
$('#parentName').val(data[0].name);
console.log(data[0].id)
console.log(data[0].name)
}
});
axios.post('grade/query',{}).then(function (response) {
let options = '<option value="">请选择年级</option>';
for(let obj of response.data){
options+='<option value="'+obj.id+'">'+obj.name+'</option>'
}
console.log(options);
$('#gradeId').append(options);
form.render('select');
}).catch();
//监听提交
form.on('submit(saveBtn)', function (data) {
axios.post('org/update',data.field).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,134 @@
<div class="layuimini-container layuimini-page-anim">
<div class="layuimini-main">
<div style="margin: 10px 10px 10px 10px">
<form class="layui-form layui-form-pane" action="">
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">姓名</label>
<div class="layui-input-inline">
<input type="text" name="name" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-inline">
<button type="submit" class="layui-btn layui-btn-primary" lay-submit lay-filter="data-search-btn"><i class="layui-icon"></i> 搜 索</button>
</div>
</div>
</form>
</div>
<script type="text/html" id="toolbarDemo">
<div class="layui-btn-container">
<button class="layui-btn layui-btn-normal layui-btn-sm data-add-btn" lay-event="update">
<i class="layui-icon layui-icon-edit"></i>
标记解决
</button>
<button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn" lay-event="delete">
<i class="layui-icon layui-icon-delete"></i>
删除
</button>
</div>
</script>
<table class="layui-hide" id="currentTableId" lay-filter="currentTableFilter"></table>
</div>
</div>
<script>
layui.use(['form', 'table','miniPage','miniAdmin','form','element','axios'], function () {
var $ = layui.jquery,
form = layui.form,
table = layui.table,
axios = layui.axios,
form = layui.form,
miniAdmin = layui.miniAdmin,
miniPage = layui.miniPage;
table.render({
elem: '#currentTableId',
method:'post',
url: 'repair/query',
toolbar: '#toolbarDemo',
defaultToolbar: ['filter', 'exports', 'print'],
cols: [[
{type: "checkbox", width: 50},
{field: 'id', width: 80, title: 'ID'},
{field: 'studentId',title: '姓名',templet:'<div>{{d.student.name}}</div>'},
{field: 'dormitoryId',title: '宿舍',templet:'<div>{{d.dormitory.no}}</div>'},
{field: 'buildingId',title: '楼宇',templet:'<div>{{d.building.name}}</div>'},
{field: 'description',title: '报修描述'},
{field: 'createDate',title: '申请时间'},
{field: 'status',title: '状态',templet: function (row) {
if(row.status == 0){
return '<span class="layui-badge layui-bg-orange">待解决</span>';
}else{
return '<span class="layui-badge layui-bg-green">已解决</span>';
}
}}
]],
page: true,
skin: 'line'
});
window.reload = function(){
table.reload('currentTableId');
}
// 监听搜索操作
form.on('submit(data-search-btn)', function (data) {
var result = JSON.stringify(data.field);
//执行搜索重载
table.reload('currentTableId', {
where: data.field
}, 'data');
return false;
});
/**
* toolbar事件监听
*/
table.on('toolbar(currentTableFilter)', function (obj) {
if (obj.event === 'update') { //修改操作
let data = table.checkStatus('currentTableId').data;
if(data.length!=1){
layer.msg("请选择一条记录修改");
}else{
axios.post('repair/update',{id:data[0].id,status:1}).then(function (response) {
layer.msg(response.msg);
table.reload('currentTableId');
});
}
}else if (obj.event === 'delete') { //删除操作
let data = table.checkStatus('currentTableId').data;
if(data.length==0){
layer.msg("请选择要删除的数据");
}else{
layer.confirm('真的删除行吗', function (index) {
//异步删除 map\filter\some\every
let arr = data.map(item=>item.id);
axios.get('repair/delete?ids='+arr.join(",")).then(function (response) {
table.reload('currentTableId');
layer.msg(response.msg);
}).catch(function (error) {
layer.msg(error);
});
layer.close(index);
});
}
}
});
function setFormValue(data){
form.val("updateForm",{
id:data.id,
dormitoryId:data.dormitoryId,
startTime:data.startTime,
endTime:data.endTime,
remark:data.remark,
})
}
});
</script>

@ -0,0 +1,111 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form">
<div class="layui-form-item">
<label class="layui-form-label required">名称</label>
<div class="layui-input-block">
<input type="text" name="name" lay-verify="required" lay-reqtext="名称不能为空" placeholder="请输入名称" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">开始时间</label>
<div class="layui-input-block">
<input type="text" name="startTime" id="startTime" lay-verify="date" placeholder="yyyy-MM-dd" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">结束时间</label>
<div class="layui-input-block">
<input type="text" name="endTime" id="endTime" lay-verify="date" placeholder="yyyy-MM-dd" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">班级</label>
<div class="layui-input-block">
<input type="hidden" name="clazzId" id="clazzId" lay-verify="required" class="layui-input">
<input type="text" name="clazzName" readonly id="clazzName" lay-verify="required" lay-reqtext="班级不能为空" placeholder="请选择班级" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item layui-form-text">
<label class="layui-form-label">备注信息</label>
<div class="layui-input-block">
<textarea name="remark" class="layui-textarea" placeholder="请输入备注信息"></textarea>
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios','laydate','selectOrg'], function () {
let form = layui.form,
layer = layui.layer,
axios = layui.axios,
laydate = layui.laydate,
selectOrg = layui.selectOrg,
$ = layui.$;
//日期
laydate.render({
elem: '#startTime'
});
laydate.render({
elem: '#endTime'
});
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
form.render();
selectOrg.render({
elem:'#clazzName',
selected:[],
checked:true,
done:function (data) {
let nameArr = data.map(item=>item.name);
$('#clazzName').val(nameArr.join(','));
let idArr = data.map(item=>item.id);
$('#clazzId').val(idArr);
}
});
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
//监听提交
form.on('submit(saveBtn)', function (data) {
let param = data.field;
if(data.field.clazzId){
param.clazzIds =data.field.clazzId.split(",");
}
axios.post('selection/create',param).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,172 @@
<div class="layuimini-main">
<div class="layuimini-main" style="width: 250px;position: absolute;left: 0px;">
<ul class="clazz"></ul>
</div>
<div class="layuimini-main" style="left: 270px;float: right;position: absolute;right:0px">
<div style="margin: 10px" id="building">
</div>
<ul class="dormitory">
</ul>
<div style="clear: both">
<button class="layui-btn layui-btn-normal" id="saveBtn">确认保存</button>
</div>
</div>
</div>
<style>
.clazz{
margin: 0px;
padding: 0px;
}
.clazz li{
height: 40px;
line-height:40px;
border-bottom: 1px solid #f1f1f1;
font-size: 16px;
cursor: pointer;
padding-left: 50px;
}
.clazz>li>span{
float: right;
margin-right: 10px;
}
.clazz>li>span>button{
cursor: pointer;
color: #00998b;
background: transparent;
border: 0px;
font-size: 20px;
}
.clazz-bg{
background-color: #f0f0f0;
color: #000000;
}
.dormitory{
margin: 0px;
padding: 0px;
}
.dormitory li{
height: 30px;
line-height:30px;
border-bottom: 1px solid #f1f1f1;
font-size: 16px;
cursor: pointer;
padding-left: 50px;
float: left;
width: 100px;
}
</style>
<script>
layui.use(['form', 'table','axios','laydate','selectOrg'], function () {
let form = layui.form,
layer = layui.layer,
axios = layui.axios,
laydate = layui.laydate,
selectOrg = layui.selectOrg,
$ = layui.$;
let _buildingId;
let _clazzId;
let clazzData = window.clazzData();
clazzData.clazzes.forEach(item=>{
let html = `<li key="${item.id}">${item.name}</li>`;
let htmlObj = $(html);
htmlObj.click(function () {
$(this).siblings().removeClass('clazz-bg');
$(this).addClass('clazz-bg');
_clazzId = $(this).attr("key");
loadDormitory(_buildingId);
});
$('.clazz').append(htmlObj);
$('.clazz li:first').trigger('click');
})
function loadBuilding(){
axios.post('building/query',{}).then(function (response) {
response.data.forEach(item=>{
let btn = '<button class="layui-btn layui-btn-primary layui-btn-radius building-btn" key='+item.id+'>'+item.name+'</button>';
let btnObj = $(btn);
btnObj.click(function () {
$(this).siblings().addClass('layui-btn-primary');
$(this).removeClass('layui-btn-primary');
loadDormitory($(this).attr("key"));
});
$('#building').append(btnObj);
})
$('#building button:first').trigger('click');
}).catch(function (error) {
layer.msg(error);
});
}
loadBuilding();
function dormitory(){
return axios.post('dormitory/query',{buildingId:_buildingId,limit:10000});
}
function selection(){
return axios.post('selectionDormitory/query',{clazzId:_clazzId,limit:10000});
}
function loadDormitory(buildingId){
_buildingId = buildingId;
axios.all([dormitory(), selection()]).then(axios.spread(function(response, response2) {
let seletionArr = response2.data.map(item=>item.dormitoryId);
$('.dormitory').empty();
response.data.forEach(item=>{
let flag = seletionArr.some(v=>v==item.id);
let obj;
if(flag){
obj = `<li><input type="checkbox" checked name="dormitoryId" value="${item.id}">${item.no}</li>`
}else{
obj = `<li><input type="checkbox" name="dormitoryId" value="${item.id}">${item.no}</li>`
}
$('.dormitory').append(obj);
})
})).catch(function (error) {
console.log(error);
})
/*axios.post('dormitory/query',{buildingId:buildingId,limit:10000}).then(function (response) {
}).catch(function (error) {
layer.msg(error);
});*/
}
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
$('#saveBtn').click(function () {
if(!_clazzId){
layer.msg("请选择班级");
return;
}
let arr = $('.dormitory input[type="checkbox"]:checked');
let str = '';
for(let i=0;i<arr.length;i++){
str+=arr[i].value+",";
}
console.log(str)
let param = {"clazzId":_clazzId,"dormitoryIds":str}
console.log(param)
axios.post('selectionDormitory/create',param).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
//layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
});
});
</script>

@ -0,0 +1,208 @@
<div class="layuimini-container layuimini-page-anim">
<div class="layuimini-main">
<div style="margin: 10px 10px 10px 10px">
<form class="layui-form layui-form-pane" action="">
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">名称</label>
<div class="layui-input-inline">
<input type="text" name="name" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-inline">
<button type="submit" class="layui-btn layui-btn-primary" lay-submit lay-filter="data-search-btn"><i class="layui-icon"></i> 搜 索</button>
</div>
</div>
</form>
</div>
<script type="text/html" id="toolbarDemo">
<div class="layui-btn-container">
<button class="layui-btn layui-btn-normal layui-btn-sm data-add-btn" lay-event="add">
<i class="layui-icon layui-icon-add-circle"></i>
新增
</button>
<button class="layui-btn layui-btn-sm layui-btn-normal data-delete-btn" lay-event="update">
<i class="layui-icon layui-icon-edit"></i>
修改
</button>
<button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn" lay-event="delete">
<i class="layui-icon layui-icon-delete"></i>
删除
</button>
<button class="layui-btn layui-btn-sm layui-btn-normal data-delete-btn" lay-event="distribute">
<i class="layui-icon layui-icon-edit"></i>
分配
</button>
</div>
</script>
<table class="layui-hide" id="currentTableId" lay-filter="currentTableFilter"></table>
</div>
</div>
<script>
layui.use(['form', 'table','miniPage','miniAdmin','form','element','axios'], function () {
var $ = layui.jquery,
form = layui.form,
table = layui.table,
axios = layui.axios,
form = layui.form,
miniAdmin = layui.miniAdmin,
miniPage = layui.miniPage;
table.render({
elem: '#currentTableId',
method:'post',
url: 'selection/query',
toolbar: '#toolbarDemo',
defaultToolbar: ['filter', 'exports', 'print'],
cols: [[
{type: "checkbox", width: 50},
{field: 'id', width: 80, title: 'ID'},
{field: 'name',title: '名称'},
{field: 'startTime', title: '开始时间'},
{field: 'endTime', title: '结束时间'},
{field: 'remark',title: '备注'}
]],
page: true,
skin: 'line'
});
window.reload = function(){
table.reload('currentTableId');
}
// 监听搜索操作
form.on('submit(data-search-btn)', function (data) {
let result = JSON.stringify(data.field);
//执行搜索重载
table.reload('currentTableId', {
where: data.field
}, 'data');
return false;
});
/**
* toolbar事件监听
*/
table.on('toolbar(currentTableFilter)', function (obj) {
if (obj.event === 'add') { // 监听添加操作
let content = miniPage.getHrefContent('selection/add.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
$(window).on("resize", function () {
layer.full(index);
});
} else if (obj.event === 'update') { //修改操作
let data = table.checkStatus('currentTableId').data;
if(data.length!=1){
layer.msg("请选择一条记录修改");
}else{
let content = miniPage.getHrefContent('selection/update.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '添加',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
setFormValue(data[0]);
$('#userId2').val(data[0].userId)
$(window).on("resize", function () {
layer.full(index);
});
}
}else if (obj.event === 'distribute') { //修改操作
let data = table.checkStatus('currentTableId').data;
if(data.length!=1){
layer.msg("请选择一条记录修改");
}else{
let content = miniPage.getHrefContent('selection/distribute.html');
let openWH = miniPage.getOpenWidthHeight();
let index = layer.open({
title: '分配',
type: 1,
shade: 0.2,
maxmin:true,
shadeClose: true,
area: [openWH[0] + 'px', openWH[1] + 'px'],
offset: [openWH[2] + 'px', openWH[3] + 'px'],
content: content
});
/*let clazzIdArr = data.clazzes.map(item=>item.id);
let clazzNameArr = data.clazzes.map(item=>item.name);*/
window.clazzData = function(){
return data[0];
}
/*data[0].clazzes.forEach(item=>{
let html = `<li key="${item.id}">${item.name}</li>`;
let htmlObj = $(html);
console.log("xxxxxxxxxxxxxxxxxxxxxxxx");
htmlObj.click(function () {
$(this).siblings().removeClass('clazz-bg');
$(this).addClass('clazz-bg');
});
$('.clazz').append(htmlObj);
})*/
$(window).on("resize", function () {
layer.full(index);
});
}
}else if (obj.event === 'delete') { //删除操作
let data = table.checkStatus('currentTableId').data;
if(data.length==0){
layer.msg("请选择要删除的数据");
}else{
layer.confirm('真的删除行吗', function (index) {
//异步删除 map\filter\some\every
let arr = data.map(item=>item.id);
axios.get('selection/delete?ids='+arr.join(",")).then(function (response) {
table.reload('currentTableId');
layer.msg(response.msg);
}).catch(function (error) {
layer.msg(error);
});
layer.close(index);
});
}
}
});
function setFormValue(data){
let clazzIdArr = data.clazzes.map(item=>item.id);
let clazzNameArr = data.clazzes.map(item=>item.name);
form.val("updateForm",{
id:data.id,
name:data.name,
startTime:data.startTime,
endTime:data.endTime,
remark:data.remark,
clazzId:clazzIdArr.join(','),
clazzName:clazzNameArr.join(','),
})
}
});
</script>

@ -0,0 +1,112 @@
<div class="layuimini-main">
<div class="layui-form layuimini-form" lay-filter="updateForm">
<div class="layui-form-item">
<label class="layui-form-label required">名称</label>
<div class="layui-input-block">
<input type="hidden" name="id" id="id">
<input type="text" name="name" lay-verify="required" lay-reqtext="名称不能为空" placeholder="请输入名称" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">开始时间</label>
<div class="layui-input-block">
<input type="text" name="startTime" id="startTime" lay-verify="date" placeholder="yyyy-MM-dd" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">结束时间</label>
<div class="layui-input-block">
<input type="text" name="endTime" id="endTime" lay-verify="date" placeholder="yyyy-MM-dd" autocomplete="off" class="layui-input">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label required">班级</label>
<div class="layui-input-block">
<input type="hidden" name="clazzId" id="clazzId" lay-verify="required" class="layui-input">
<input type="text" name="clazzName" readonly id="clazzName" lay-verify="required" lay-reqtext="班级不能为空" placeholder="请选择班级" value="" class="layui-input">
</div>
</div>
<div class="layui-form-item layui-form-text">
<label class="layui-form-label">备注信息</label>
<div class="layui-input-block">
<textarea name="remark" class="layui-textarea" placeholder="请输入备注信息"></textarea>
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block">
<button class="layui-btn layui-btn-normal" lay-submit lay-filter="saveBtn">确认保存</button>
</div>
</div>
</div>
</div>
<script>
layui.use(['form', 'table','axios','laydate','selectOrg'], function () {
let form = layui.form,
layer = layui.layer,
axios = layui.axios,
laydate = layui.laydate,
selectOrg = layui.selectOrg,
$ = layui.$;
//日期
laydate.render({
elem: '#startTime'
});
laydate.render({
elem: '#endTime'
});
/**
* 初始化表单,要加上,不然刷新部分组件可能会不加载
*/
form.render();
selectOrg.render({
elem:'#clazzName',
selected:[],
checked:true,
done:function (data) {
let nameArr = data.map(item=>item.name);
$('#clazzName').val(nameArr.join(','));
let idArr = data.map(item=>item.id);
$('#clazzId').val(idArr);
}
});
// 当前弹出层防止ID被覆盖
let parentIndex = layer.index;
//监听提交
form.on('submit(saveBtn)', function (data) {
let param = data.field;
if(data.field.clazzId){
param.clazzIds =data.field.clazzId.split(",");
}
axios.post('selection/update',param).then(function(response){
if(response.code == 200){
layer.msg(response.msg);
window.reload();
}
layer.close(parentIndex);
}).catch(function (error) {
layer.msg(error);
});
return false;
});
});
</script>

@ -0,0 +1,15 @@
package com.yanzhen.framework.exception;
// 定义一个名为MyException的类继承自RuntimeException
public class MyException extends RuntimeException {
// 无参构造函数
public MyException() {
}
// 带一个字符串参数的构造函数
public MyException(String message) {
// 调用父类的构造函数,并传递消息参数
super(message);
}
}

@ -0,0 +1,237 @@
package com.yanzhen.framework.jwt;
import com.yanzhen.entity.Student; // 导入Student类
import com.yanzhen.entity.User; // 导入User类
import com.yanzhen.framework.exception.MyException; // 导入自定义异常类MyException
import io.jsonwebtoken.*; // 导入JWT相关类
import org.springframework.util.StringUtils; // 导入Spring框架的StringUtils工具类
import java.util.Date; // 导入Date类
import java.util.HashMap; // 导入HashMap类
import java.util.Map; // 导入Map接口
import java.util.UUID; // 导入UUID类
//jwt的工具类
public class JWTUtil {
// 定义静态变量token用于存储token字符串
public static String token = "token";
//秘钥
// 定义静态变量jwt_secret用于存储JWT签名的密钥
public static String jwt_secret="yanzhen@cms@cc596183363.";
//过期时长
// 定义静态变量jwt_expr用于设置JWT的过期时间单位毫秒
public static long jwt_expr = 3600*24*1000;
//1、生成token
// 定义静态方法sign用于生成用户类型的JWT
public static String sign(User user){
//1、指定签名的时候使用的签名算法
// 使用HS256算法进行签名
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
//2、生成签发时间
// 获取当前时间的毫秒数
long nowMillis = System.currentTimeMillis();
// 将毫秒数转换为Date对象
Date date = new Date(nowMillis);
//3、创建playLoad的私有声明
// 创建一个Map对象用于存储JWT的负载信息
Map<String,Object> claims = new HashMap<>();
// 将用户的ID添加到负载中
claims.put("id",user.getId());
// 将用户名添加到负载中
claims.put("userName",user.getUserName());
// 添加类型信息到负载中
claims.put("type","USER");
//4、生成签发人
// 将用户名作为JWT的签发人
String subject = user.getUserName();
// 创建JwtBuilder对象用于构建JWT
JwtBuilder builder = Jwts.builder()
// 设置JWT的负载信息
.setClaims(claims)
// 设置JWT的唯一标识符
.setId(UUID.randomUUID().toString())
// 设置JWT的签发时间
.setIssuedAt(date)
// 设置JWT的签发人
.setSubject(subject)
// 使用指定的签名算法和密钥对JWT进行签名
.signWith(signatureAlgorithm,jwt_secret);
//设置过期时间
// 计算JWT的过期时间
Date exprDate = new Date(nowMillis + jwt_expr);
// 设置JWT的过期时间
builder.setExpiration(exprDate);
// 生成并返回JWT字符串
return builder.compact();
}
//1、生成token
// 定义静态方法signForStudent用于生成学生类型的JWT
public static String signForStudent(Student student){
//1、指定签名的时候使用的签名算法
// 使用HS256算法进行签名
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
//2、生成签发时间
// 获取当前时间的毫秒数
long nowMillis = System.currentTimeMillis();
// 将毫秒数转换为Date对象
Date date = new Date(nowMillis);
//3、创建playLoad的私有声明
// 创建一个Map对象用于存储JWT的负载信息
Map<String,Object> claims = new HashMap<>();
// 将学生的ID添加到负载中
claims.put("id",student.getId());
// 将学号添加到负载中
claims.put("stuNo",student.getStuNo());
// 添加类型信息到负载中
claims.put("type","STUDENT");
//4、生成签发人
// 将学号作为JWT的签发人
String subject = student.getStuNo();
// 创建JwtBuilder对象用于构建JWT
JwtBuilder builder = Jwts.builder()
// 设置JWT的负载信息
.setClaims(claims)
// 设置JWT的唯一标识符
.setId(UUID.randomUUID().toString())
// 设置JWT的签发时间
.setIssuedAt(date)
// 设置JWT的签发人
.setSubject(subject)
// 使用指定的签名算法和密钥对JWT进行签名
.signWith(signatureAlgorithm,jwt_secret);
//设置过期时间
// 计算JWT的过期时间
Date exprDate = new Date(nowMillis + jwt_expr);
// 设置JWT的过期时间
builder.setExpiration(exprDate);
// 生成并返回JWT字符串
return builder.compact();
}
//2、验证token
// 定义静态方法verify用于验证JWT是否合法
public static boolean verify(String token){
try {
// 如果token为空则返回false
if(StringUtils.isEmpty(token)){
return false;
}
// 解析JWT并验证签名
Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody();
// 如果解析成功且签名合法则返回true
return true;
// 如果解析或验证过程中发生异常,则捕获异常
} catch (Exception e) {
// 打印异常堆栈信息
e.printStackTrace();
// 返回false表示验证失败
return false;
}
}
// 定义静态方法getType用于获取JWT的类型信息
public static String getType(String token){
try {
// 如果token为空则抛出自定义异常
if(StringUtils.isEmpty(token)){
throw new MyException("token不能为空");
}
// 如果token验证通过则解析JWT并获取类型信息
if(verify(token)){
// 解析JWT并获取负载信息
Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody();
// 返回类型信息
return claims.get("type")+"";
}else{
// 如果token验证失败则抛出自定义异常
throw new MyException("超时或不合法token");
}
// 如果解析或验证过程中发生异常,则捕获异常
} catch (Exception e) {
// 抛出自定义异常
throw new MyException("超时或不合法token");
}
}
//3、获取用户信息
// 定义静态方法getUser用于从JWT中提取用户信息
public static User getUser(String token){
try {
// 如果token为空则抛出自定义异常
if(StringUtils.isEmpty(token)){
throw new MyException("token不能为空");
}
// 如果token验证通过则解析JWT并获取用户信息
if(verify(token)){
// 解析JWT并获取负载信息
Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody();
// 创建User对象
User user = new User();
// 从负载中提取用户ID并设置到User对象中
user.setId(Integer.parseInt(claims.get("id")+""));
// 从负载中提取用户名并设置到User对象中
user.setUserName(claims.get("userName")+"");
// 返回User对象
return user;
}else{
// 如果token验证失败则抛出自定义异常
throw new MyException("超时或不合法token");
}
// 如果解析或验证过程中发生异常,则捕获异常
} catch (Exception e) {
// 抛出自定义异常
throw new MyException("超时或不合法token");
}
}
// 定义静态方法getStudent用于从JWT中提取学生信息
public static Student getStudent(String token){
try {
// 如果token为空则抛出自定义异常
if(StringUtils.isEmpty(token)){
throw new MyException("token不能为空");
}
// 如果token验证通过则解析JWT并获取学生信息
if(verify(token)){
// 解析JWT并获取负载信息
Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody();
// 创建Student对象
Student student = new Student();
// 从负载中提取学生ID并设置到Student对象中
student.setId(Integer.parseInt(claims.get("id")+""));
// 从负载中提取学号并设置到Student对象中
student.setStuNo(claims.get("stuNo")+"");
// 返回Student对象
return student;
}else{
// 如果token验证失败则抛出自定义异常
throw new MyException("超时或不合法token");
}
// 如果解析或验证过程中发生异常,则捕获异常
} catch (Exception e) {
// 抛出自定义异常
throw new MyException("超时或不合法token");
}
}
// 主方法,程序入口点
public static void main(String[] args) {
// 创建User对象
User user = new User();
// 设置用户ID
user.setId(1);
// 设置用户名
user.setUserName("admin");
// 生成用户类型的JWT并打印输出
System.out.println(sign(user));
}
}

@ -0,0 +1,37 @@
package com.yanzhen.framework.mvc;
import com.yanzhen.framework.exception.MyException; // 导入自定义异常类
import com.yanzhen.utils.Result; // 导入结果处理工具类
import org.springframework.web.bind.annotation.ControllerAdvice; // 导入Spring MVC的ControllerAdvice注解
import org.springframework.web.bind.annotation.ExceptionHandler; // 导入Spring MVC的ExceptionHandler注解
import org.springframework.web.bind.annotation.RequestBody; // 导入Spring MVC的RequestBody注解
import org.springframework.web.bind.annotation.ResponseBody; // 导入Spring MVC的ResponseBody注解
// 全局异常处理类
@ControllerAdvice
public class GlobalControllerAdvice {
// 处理所有RuntimeException类型的异常
@ExceptionHandler(RuntimeException.class)
@ResponseBody
// 定义处理方法,参数为捕获到的异常
public Result handle(RuntimeException exception){
// 打印异常堆栈信息
exception.printStackTrace();
// 返回失败的结果对象,包含异常信息
return Result.fail(exception.getMessage());
}
// 处理所有MyException类型的异常
@ExceptionHandler(MyException.class)
// 将返回值作为HTTP响应体
@ResponseBody
// 定义处理方法,参数为捕获到的异常
public Result handle(MyException exception){
// 打印异常堆栈信息
exception.printStackTrace();
// 返回失败的结果对象,包含错误码和异常信息
return Result.fail(Result.TOKEN_ERROR,exception.getMessage());
}
}

@ -0,0 +1,42 @@
package com.yanzhen.framework.mvc; // 定义包名
import org.springframework.context.annotation.Bean; // 导入@Bean注解
import org.springframework.context.annotation.Configuration; // 导入@Configuration注解
import org.springframework.web.cors.CorsConfiguration; // 导入CorsConfiguration类
import org.springframework.web.cors.CorsConfigurationSource; // 导入CorsConfigurationSource接口
import org.springframework.web.cors.UrlBasedCorsConfigurationSource; // 导入UrlBasedCorsConfigurationSource类
import org.springframework.web.filter.CorsFilter; // 导入CorsFilter类
import org.springframework.web.servlet.config.annotation.InterceptorRegistry; // 导入InterceptorRegistry类
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 导入WebMvcConfigurer接口
@Configuration // 标记该类为配置类
public class MyWebMvcConfigurer implements WebMvcConfigurer { // 实现WebMvcConfigurer接口
@Bean // 将方法返回的对象注册为Spring容器中的Bean
public TokenInterceptor tokenInterceptor(){ // 定义tokenInterceptor方法返回TokenInterceptor对象
return new TokenInterceptor(); // 创建并返回TokenInterceptor实例
}
@Override // 重写父类的方法
public void addInterceptors(InterceptorRegistry registry) { // 定义addInterceptors方法参数为InterceptorRegistry对象
registry.addInterceptor(tokenInterceptor()) // 添加自定义拦截器
.addPathPatterns("/**") // 设置拦截所有路径
.excludePathPatterns("/login"); // 排除登录路径不拦截
}
//使用CorsFilter解决跨域的问题
@Bean // 将方法返回的对象注册为Spring容器中的Bean
public CorsFilter corsFilter(){ // 定义corsFilter方法返回CorsFilter对象
CorsConfiguration corsConfiguration = new CorsConfiguration(); // 创建CorsConfiguration实例
//允许跨域请求的域名
corsConfiguration.addAllowedOrigin("*"); // 允许所有域名进行跨域请求
corsConfiguration.addAllowedMethod("*"); // 允许所有HTTP方法进行跨域请求
//允许任何头部
corsConfiguration.addAllowedHeader("*"); // 允许所有头部信息进行跨域请求
UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource(); // 创建UrlBasedCorsConfigurationSource实例
urlBasedCorsConfigurationSource.registerCorsConfiguration("/**",corsConfiguration); // 注册跨域配置到URL模式
CorsFilter corsFilter = new CorsFilter(urlBasedCorsConfigurationSource); // 创建CorsFilter实例
return corsFilter; // 返回CorsFilter实例
}
}

@ -0,0 +1,53 @@
package com.yanzhen.framework.mvc; // 定义包名
import com.yanzhen.entity.Student; // 导入Student类
import com.yanzhen.entity.User; // 导入User类
import com.yanzhen.framework.exception.MyException; // 导入自定义异常类MyException
import com.yanzhen.framework.jwt.JWTUtil; // 导入JWT工具类JWTUtil
import org.springframework.web.servlet.HandlerInterceptor; // 导入Spring MVC的HandlerInterceptor接口
import org.springframework.web.servlet.ModelAndView; // 导入Spring MVC的ModelAndView类
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类
import javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类
public class TokenInterceptor implements HandlerInterceptor { // 定义TokenInterceptor类并实现HandlerInterceptor接口
@Override // 重写preHandle方法在请求处理之前进行调用
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String token = request.getHeader(JWTUtil.token); // 从请求头中获取token
String type = JWTUtil.getType(token); // 根据token获取类型
if("USER".equals(type)){ // 如果类型是USER
//根据token获取user对象
User user = JWTUtil.getUser(token); // 通过JWT工具类获取User对象
if(user == null){ // 如果User对象为空
throw new MyException("超时或不合法的token"); // 抛出自定义异常
}
String newToken = JWTUtil.sign(user); // 重新生成新的token
response.setHeader(JWTUtil.token,newToken); // 将新token设置到响应头中
response.setHeader("Access-Control-Expose-Headers", JWTUtil.token); // 设置允许暴露的响应头
request.setAttribute("user",user); // 将User对象设置到请求属性中
}else if("STUDENT".equals(type)){ // 如果类型是STUDENT
//根据token获取user对象
Student student = JWTUtil.getStudent(token); // 通过JWT工具类获取Student对象
if(student == null){ // 如果Student对象为空
throw new MyException("超时或不合法的token"); // 抛出自定义异常
}
String newToken = JWTUtil.signForStudent(student); // 重新生成新的token
response.setHeader(JWTUtil.token,newToken); // 将新token设置到响应头中
response.setHeader("Access-Control-Expose-Headers", JWTUtil.token); // 设置允许暴露的响应头
request.setAttribute("student",student); // 将Student对象设置到请求属性中
}
return true; // 返回true表示继续执行后续的拦截器和处理器
}
@Override // 重写postHandle方法在请求处理之后但在视图渲染之前进行调用
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
@Override // 重写afterCompletion方法在整个请求结束之后进行调用
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}

@ -0,0 +1,25 @@
package com.yanzhen.mapper; // 定义包名表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类用于处理列表数据结构
import com.yanzhen.entity.Absence; // 导入Absence缺勤实体类用于操作缺勤信息
public interface AbsenceMapper { // 定义AbsenceMapper接口提供对Absence缺勤实体进行数据库操作的方法
// 创建一个新的Absence缺勤记录
public int create(Absence absence);
// 根据id删除缺勤
public int delete(Integer id);
// 更新缺勤记录
public int update(Absence absence);
// 选择性地更新缺勤记录
public int updateSelective(Absence absence);
// 根据条件查询缺勤记录,返回缺勤列表
public List<Absence> query(Absence absence);
// 根据id查询一个缺勤记录的详细信息
public Absence detail(Integer id);
// 统计缺勤记录的数量
public int count(Absence absence);
}

@ -0,0 +1,78 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.AbsenceMapper">
<resultMap type="com.yanzhen.entity.Absence" id="Absence">
<id column="id" property="id"/>
<result column="student_id" property="studentId"/>
<result column="dormitory_id" property="dormitoryId"/>
<result column="start_time" property="startTime"/>
<result column="end_time" property="endTime"/>
<result column="remark" property="remark"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Absence">
insert into tb_absence(
student_id,
dormitory_id,
start_time,
end_time,
remark
)values(
#{studentId},
#{dormitoryId},
#{startTime},
#{endTime},
#{remark}
)
</insert>
<select id="query" resultMap="Absence">
select * from tb_absence
<include refid="AbsenceFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_absence
<include refid="AbsenceFindCriteria"/>
</select>
<select id="detail" resultMap="Absence">
select * from tb_absence where id = #{id}
</select>
<delete id="delete">
delete from tb_absence where id = #{id}
</delete>
<update id="update">
update tb_absence set
student_id=#{studentId},
dormitory_id=#{dormitoryId},
start_time=#{startTime},
end_time=#{endTime},
remark=#{remark}
where id = #{id}
</update>
<update id="updateSelective">
update tb_absence
<set>
<if test="studentId != null">student_id = #{studentId},</if>
<if test="dormitoryId != null">dormitory_id = #{dormitoryId},</if>
<if test="startTime != null"> start_time = #{startTime},</if>
<if test="endTime != null"> end_time = #{endTime},</if>
<if test="remark != null and remark != ''"> remark = #{remark},</if>
</set>
where id = #{id}
</update>
<sql id="AbsenceFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="studentId != null">and student_id = #{studentId}</if>
<if test="dormitoryId != null">and dormitory_id = #{dormitoryId}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,27 @@
package com.yanzhen.mapper; // 定义包名表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类用于处理列表数据结构
import com.yanzhen.entity.Bed; // 导入Bed床实体类用于操作床位信息
// 定义接口提供对Bed床实体进行数据库操作的方法
public interface BedMapper {
// 创建一个新的Bed记录返回影响的行数
public int create(Bed bed);
// 根据id删除一个Bed记录
public int delete(Integer id);
// 根据宿舍ID删除相关的Bed记录
public int deleteByDormitoryId(Integer dormitoryId);
// 更新一个Bed记录
public int update(Bed bed);
// 选择性地更新一个Bed记录
public int updateSelective(Bed bed);
// 根据设置的条件查询Bed记录返回符合条件的Bed列表
public List<Bed> query(Bed bed);
// 根据id查询一个Bed记录的详细信息
public Bed detail(Integer id);
// 统计Bed记录的数量返回数量
public int count(Bed bed);
}

@ -0,0 +1,65 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.BedMapper">
<resultMap type="com.yanzhen.entity.Bed" id="Bed">
<id column="id" property="id"/>
<result column="bno" property="bno"/>
<result column="dormitory_id" property="dormitoryId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Bed">
insert into tb_bed(
bno,
dormitory_id
)values(
#{bno},
#{dormitoryId}
)
</insert>
<select id="query" resultMap="Bed">
select * from tb_bed
<include refid="BedFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_bed
<include refid="BedFindCriteria"/>
</select>
<select id="detail" resultMap="Bed">
select * from tb_bed where id = #{id}
</select>
<delete id="delete">
delete from tb_bed where id = #{id}
</delete>
<delete id="deleteByDormitoryId">
delete from tb_bed where dormitory_id = #{dormitoryId}
</delete>
<update id="update">
update tb_bed set
bno=#{bno},
dormitory_id=#{dormitoryId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_bed set
<if test="bno != null and bno != ''"> bno = #{bno}</if>,
<if test="dormitoryId != null">dormitory_id = #{dormitoryId}</if>
where id = #{id}
</update>
<sql id="BedFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="bno != null and bno != ''">and bno = #{bno}</if>
<if test="dormitoryId != null">and dormitory_id = #{dormitoryId}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,24 @@
package com.yanzhen.mapper; // 定义包名表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类用于处理列表数据结构
import com.yanzhen.entity.Building; // 导入Building楼宇实体类用于操作楼宇信息
// 定义BuildingMapper接口
public interface BuildingMapper {
// 创建一个新的Building楼宇记录
public int create(Building building);
// 根据id删除一个Building
public int delete(Integer id);
// 更新一个Building
public int update(Building building);
// 选择性地更新一个Building
public int updateSelective(Building building);
// 根据条件查询Building返回符合条件的Building楼宇列表
public List<Building> query(Building building);
// 根据id查询一个Building楼宇记录的详细信息
public Building detail(Integer id);
// 根据条件统计Building楼宇记录的数量
public int count(Building building);
}

@ -0,0 +1,84 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.BuildingMapper">
<resultMap type="com.yanzhen.entity.Building" id="Building">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="type" property="type"/>
<result column="storey_num" property="storeyNum"/>
<result column="sex" property="sex"/>
<result column="remark" property="remark"/>
<result column="user_id" property="userId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Building">
insert into tb_building(
name,
type,
storey_num,
sex,
remark,
user_id
)values(
#{name},
#{type},
#{storeyNum},
#{sex},
#{remark},
#{userId}
)
</insert>
<select id="query" resultMap="Building">
select * from tb_building
<include refid="BuildingFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_building
<include refid="BuildingFindCriteria"/>
</select>
<select id="detail" resultMap="Building">
select * from tb_building where id = #{id}
</select>
<delete id="delete">
delete from tb_building where id = #{id}
</delete>
<update id="update">
update tb_building set
name=#{name},
type=#{type},
storey_num=#{storeyNum},
sex=#{sex},
remark=#{remark},
user_id=#{userId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_building set
<if test="name != null and name != ''"> name = #{name}</if>,
<if test="type != null">type = #{type}</if>,
<if test="storeyNum != null">storey_num = #{storeyNum}</if>,
<if test="sex != null">sex = #{sex}</if>,
<if test="remark != null and remark != ''"> remark = #{remark}</if>,
<if test="userId != null">user_id = #{userId}</if>
where id = #{id}
</update>
<sql id="BuildingFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="name != null and name != ''">and name like concat('%',#{name},'%')</if>
<if test="type != null">and type = #{type}</if>
<if test="storeyNum != null">and storey_num = #{storeyNum}</if>
<if test="sex != null">and sex = #{sex}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
<if test="userId != null">and user_id = #{userId}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,29 @@
package com.yanzhen.mapper; // 定义包名表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类用于处理列表数据结构
import com.yanzhen.entity.Dormitory; // 导入Dormitory宿舍实体类用于操作宿舍信息
import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解用于传递参数到SQL语句中
// 定义DormitoryMapper接口提供对Dormitory的方法
public interface DormitoryMapper {
// 创建Dormitory宿舍记录
public int create(Dormitory dormitory);
// 根据id删除Dormitory宿舍记录
public int delete(Integer id);
// 更新一个Dormitory
public int update(Dormitory dormitory);
// 选择性地更新一个Dormitory
public int updateSelective(Dormitory dormitory);
// 根据条件查询Dormitory并返回符合设置条件的Dormitory宿舍列表
public List<Dormitory> query(Dormitory dormitory);
// 根据id查询Dormitory宿舍记录的详细信息
public Dormitory detail(Integer id);
// 根据条件统计Dormitory的数量
public int count(Dormitory dormitory);
// 根据建筑ID和楼层ID删除Dormitory
public int deleteByBuildingIdAndStoryId(@Param("buildingId") Integer buildingId, @Param("storeyId")Integer storeyId);
}

@ -0,0 +1,90 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.DormitoryMapper">
<resultMap type="com.yanzhen.entity.Dormitory" id="Dormitory">
<id column="id" property="id"/>
<result column="no" property="no"/>
<result column="sex" property="sex"/>
<result column="type" property="type"/>
<result column="capacity" property="capacity"/>
<result column="storey_id" property="storeyId"/>
<result column="building_id" property="buildingId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Dormitory">
insert into tb_dormitory(
no,
sex,
type,
capacity,
storey_id,
building_id
)values(
#{no},
#{sex},
#{type},
#{capacity},
#{storeyId},
#{buildingId}
)
</insert>
<select id="query" resultMap="Dormitory">
select * from tb_dormitory
<include refid="DormitoryFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_dormitory
<include refid="DormitoryFindCriteria"/>
</select>
<select id="detail" resultMap="Dormitory">
select * from tb_dormitory where id = #{id}
</select>
<delete id="delete">
delete from tb_dormitory where id = #{id}
</delete>
<delete id="deleteByBuildingIdAndStoryId">
delete from tb_dormitory where building_id = #{buildingId} and storey_id = #{storeyId}
</delete>
<update id="update">
update tb_dormitory set
no=#{no},
sex=#{sex},
type=#{type},
capacity=#{capacity},
storey_id=#{storeyId},
building_id=#{buildingId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_dormitory set
<if test="no != null and no != ''"> no = #{no}</if>,
<if test="sex != null">sex = #{sex}</if>,
<if test="type != null">type = #{type}</if>,
<if test="capacity != null">capacity = #{capacity}</if>,
<if test="storeyId != null">storey_id = #{storeyId}</if>,
<if test="buildingId != null">building_id = #{buildingId}</if>
where id = #{id}
</update>
<sql id="DormitoryFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="no != null and no != ''">and no = #{no}</if>
<if test="sex != null">and sex = #{sex}</if>
<if test="type != null">and type = #{type}</if>
<if test="capacity != null">and capacity = #{capacity}</if>
<if test="storeyId != null">and storey_id = #{storeyId}</if>
<if test="buildingId != null">and building_id = #{buildingId}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,24 @@
package com.yanzhen.mapper; // 定义包名表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类用于处理列表数据结构
import com.yanzhen.entity.DormitorySet; // 导入DormitorySet宿舍设置实体类用于操作宿舍设置信息
// 定义DormitorySetMapper接口提供对DormitorySet宿舍设置实体的方法
public interface DormitorySetMapper {
//创建新的宿舍设置记录
public int create(DormitorySet dormitorySet);
//删除宿舍设置记录
public int delete(Integer id);
// 更新一个DormitorySet宿舍设置记录
public int update(DormitorySet dormitorySet);
// 选择性地更新一个宿舍设置记录
public int updateSelective(DormitorySet dormitorySet);
// 根据条件查询宿舍设置记录
public List<DormitorySet> query(DormitorySet dormitorySet);
// 根据id查询一个宿舍设置记录的详细信息
public DormitorySet detail(Integer id);
// 根据条件统计宿舍设置记录的数量,返回记录数量
public int count(DormitorySet dormitorySet);
}

@ -0,0 +1,84 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.DormitorySetMapper">
<resultMap type="com.yanzhen.entity.DormitorySet" id="DormitorySet">
<id column="id" property="id"/>
<result column="prefix" property="prefix"/>
<result column="start" property="start"/>
<result column="end" property="end"/>
<result column="building_id" property="buildingId"/>
<result column="storey_id" property="storeyId"/>
<result column="capacity" property="capacity"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.DormitorySet">
insert into tb_dormitory_set(
prefix,
start,
end,
building_id,
storey_id,
capacity
)values(
#{prefix},
#{start},
#{end},
#{buildingId},
#{storeyId},
#{capacity}
)
</insert>
<select id="query" resultMap="DormitorySet">
select * from tb_dormitory_set
<include refid="DormitorySetFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_dormitory_set
<include refid="DormitorySetFindCriteria"/>
</select>
<select id="detail" resultMap="DormitorySet">
select * from tb_dormitory_set where id = #{id}
</select>
<delete id="delete">
delete from tb_dormitory_set where id = #{id}
</delete>
<update id="update">
update tb_dormitory_set set
prefix=#{prefix},
start=#{start},
end=#{end},
building_id=#{buildingId},
storey_id=#{storeyId},
capacity=#{capacity}
where id = #{id}
</update>
<update id="updateSelective">
update tb_dormitory_set set
<if test="prefix != null and prefix != ''"> prefix = #{prefix}</if>,
<if test="start != null">start = #{start}</if>,
<if test="end != null">end = #{end}</if>,
<if test="buildingId != null">building_id = #{buildingId}</if>,
<if test="storeyId != null">storey_id = #{storeyId}</if>,
<if test="capacity != null">capacity = #{capacity}</if>
where id = #{id}
</update>
<sql id="DormitorySetFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="prefix != null and prefix != ''">and prefix = #{prefix}</if>
<if test="start != null">and start = #{start}</if>
<if test="end != null">and end = #{end}</if>
<if test="buildingId != null">and building_id = #{buildingId}</if>
<if test="storeyId != null">and storey_id = #{storeyId}</if>
<if test="capacity != null">and capacity = #{capacity}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,32 @@
// 定义包名表示该接口属于com.yanzhen.mapper包
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.DormitoryStudent; // 导入DormitoryStudent实体类用于操作学生宿舍信息
import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解用于传递参数到SQL语句中
// 定义DormitoryStudentMapper接口提供对DormitoryStudent实体的方法
public interface DormitoryStudentMapper {
// 创建一个新的DormitoryStudent记录
public int create(DormitoryStudent dormitoryStudent);
// 根据id删除一个记录
public int delete(Integer id);
// 根据条件删除记录
public int deleteByCond(@Param("studentId") Integer studentId, @Param("dormitoryId")Integer dormitoryId);
// 更新一个记录
public int update(DormitoryStudent dormitoryStudent);
// 选择性地更新一个DormitoryStudent记录
public int updateSelective(DormitoryStudent dormitoryStudent);
// 根据条件查询DormitoryStudent记录返回符合条件的DormitoryStudent列表
public List<DormitoryStudent> query(DormitoryStudent dormitoryStudent);
// 根据id查询一个DormitoryStudent记录的详细信息
public DormitoryStudent detail(Integer id);
// 根据条件统计记录的数量
public int count(DormitoryStudent dormitoryStudent);
// 根据buildingId统计DormitoryStudent记录的数量
public int countByBuildingId(Integer buildingId);
// 根据bedId查询学生信息返回包含学生信息的Map对象
public Map<String,Object> queryStudentByBedId(Integer bedId);
}

@ -0,0 +1,95 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.DormitoryStudentMapper">
<resultMap type="com.yanzhen.entity.DormitoryStudent" id="DormitoryStudent">
<id column="id" property="id"/>
<result column="dormitory_id" property="dormitoryId"/>
<result column="bed_id" property="bedId"/>
<result column="student_id" property="studentId"/>
<result column="checkin" property="checkin"/>
<result column="status" property="status"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.DormitoryStudent">
insert into tb_dormitory_student(
dormitory_id,
bed_id,
student_id,
checkin,
status
)values(
#{dormitoryId},
#{bedId},
#{studentId},
#{checkin},
#{status}
)
</insert>
<select id="query" resultMap="DormitoryStudent">
select * from tb_dormitory_student
<include refid="DormitoryStudentFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_dormitory_student
<include refid="DormitoryStudentFindCriteria"/>
</select>
<select id="detail" resultMap="DormitoryStudent">
select * from tb_dormitory_student where id = #{id}
</select>
<delete id="delete">
delete from tb_dormitory_student where id = #{id}
</delete>
<delete id="deleteByCond">
delete from tb_dormitory_student where student_id = #{studentId}
</delete>
<update id="update">
update tb_dormitory_student set
dormitory_id=#{dormitoryId},
bed_id=#{bedId},
student_id=#{studentId},
checkin=#{checkin},
status=#{status}
where id = #{id}
</update>
<update id="updateSelective">
update tb_dormitory_student set
<if test="dormitoryId != null">dormitory_id = #{dormitoryId}</if>,
<if test="bedId != null">bed_id = #{bedId}</if>,
<if test="studentId != null">student_id = #{studentId}</if>,
<if test="checkin != null and checkin != ''"> checkin = #{checkin}</if>,
<if test="status != null">status = #{status}</if>
where id = #{id}
</update>
<sql id="DormitoryStudentFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="dormitoryId != null">and dormitory_id = #{dormitoryId}</if>
<if test="bedId != null">and bed_id = #{bedId}</if>
<if test="studentId != null">and student_id = #{studentId}</if>
<if test="status != null">and status = #{status}</if>
</where>
</sql>
<!--查询楼宇入住数量-->
<select id="countByBuildingId" resultType="int">
select count(distinct student_id) cnt from tb_dormitory_student,tb_dormitory where tb_dormitory_student.dormitory_id = tb_dormitory.id
and building_id = #{buildingId}
</select>
<!--查询床位对应的学生-->
<select id="queryStudentByBedId" resultType="java.util.HashMap">
select student_id,tb_student.name from tb_dormitory_student ,tb_student where
tb_dormitory_student.student_id = tb_student.id and bed_id = #{bedId} limit 1
</select>
</mapper>

@ -0,0 +1,26 @@
// 定义包名表示该接口属于com.yanzhen.mapper包
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Grade; // 导入Grade实体类用于操作年级信息
// 定义GradeMapper接口
public interface GradeMapper {
// 创建一个新的Grade记录
public int create(Grade grade);
// 根据id删除一个Grade
public int delete(Integer id);
// 更新一个Grade
public int update(Grade grade);
// 选择性地更新一个Grade记录
public int updateSelective(Grade grade);
// 根据条件查询Grade记录返回符合条件的Grade列表
public List<Grade> query(Grade grade);
// 从id查询一个Grade的详细信息返回Grade对象
public Grade detail(Integer id);
// 根据条件统计Grade记录的数量
public int count(Grade grade);
}

@ -0,0 +1,54 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.GradeMapper">
<resultMap type="com.yanzhen.entity.Grade" id="Grade">
<id column="id" property="id"/>
<result column="name" property="name"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Grade">
insert into tb_grade(
name
)values(
#{name}
)
</insert>
<select id="query" resultMap="Grade">
select * from tb_grade
<include refid="GradeFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_grade
<include refid="GradeFindCriteria"/>
</select>
<select id="detail" resultMap="Grade">
select * from tb_grade where id = #{id}
</select>
<delete id="delete">
delete from tb_grade where id = #{id}
</delete>
<update id="update">
update tb_grade set
name=#{name}
where id = #{id}
</update>
<update id="updateSelective">
update tb_grade set
<if test="name != null and name != ''"> name = #{name}</if>
where id = #{id}
</update>
<sql id="GradeFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="name != null and name != ''">and name = #{name}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,24 @@
// 定义包名
package com.yanzhen.mapper;
import com.yanzhen.entity.Menu; // 导入Menu实体类
import com.yanzhen.entity.User; // 导入User实体类
import org.apache.ibatis.annotations.Param; // 导入MyBatis的@Param注解
import java.util.List; // 导入List集合
// 定义MenuMapper接口
public interface MenuMapper {
// 根据用户ID查询菜单列表
public List<Menu> query(Integer userId);
// 查询所有类型的菜单列表
public List<Menu> queryByType();
// 列出所有菜单列表
public List<Menu> list();
// 为用户创建菜单关联用户ID和菜单ID
public int createUserMenu(@Param("userId") Integer userId, @Param("menuId") Integer menuId);
// 删除用户的菜单
public int deleteUserMenu(@Param("userId") Integer userId);
// 查询用户已选择的菜单ID列表
public List<Integer> queryCheckMenuId(Integer userId);
}

@ -0,0 +1,41 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.MenuMapper">
<resultMap id="Menu" type="com.yanzhen.entity.Menu">
<id column="id" property="id"/>
<result column="title" property="title"/>
<result column="icon" property="icon"/>
<result column="href" property="href"/>
<result column="target" property="target"/>
<result column="parent_id" property="parentId"/>
<result column="type" property="type"/>
</resultMap>
<insert id="deleteUserMenu">
delete from tb_user_menu where user_id = #{userId}
</insert>
<insert id="createUserMenu">
insert into tb_user_menu(user_id,menu_id) values(#{userId},#{menuId})
</insert>
<select id="query" resultMap="Menu">
select tb_menu.* from tb_menu,tb_user_menu where tb_menu.id=tb_user_menu.menu_id
and user_id = #{userId} and tb_menu.type = 0
</select>
<select id="queryByType" resultMap="Menu">
select tb_menu.* from tb_menu where type = 1
</select>
<select id="queryCheckMenuId" resultType="int">
select menu_id from tb_user_menu where user_id = #{userId}
</select>
<select id="list" resultMap="Menu">
select tb_menu.* from tb_menu where type = 0
</select>
</mapper>

@ -0,0 +1,28 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入List集合类
import java.util.Map; // 导入Map集合类
import com.yanzhen.entity.Notice; // 导入Notice实体类
// 定义NoticeMapper接口
public interface NoticeMapper {
// 创建Notice记录返回受影响的行数
public int create(Notice notice);
// 根据ID删除Notice记录
public int delete(Integer id);
// 更新Notice记录
public int update(Notice notice);
// 选择性更新Notice记录
public int updateSelective(Notice notice);
// 根据条件查询Notice列表
public List<Notice> query(Notice notice);
// 根据建筑ID查询Notice列表
public List<Notice> queryByBuildingId(Notice notice);
// 根据ID查询Notice详情
public Notice detail(Integer id);
// 统计符合条件的Notice数量并返回
public int count(Notice notice);
}

@ -0,0 +1,85 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.NoticeMapper">
<resultMap type="com.yanzhen.entity.Notice" id="Notice">
<id column="id" property="id"/>
<result column="title" property="title"/>
<result column="content" property="content"/>
<result column="create_time" property="createTime"/>
<result column="user_id" property="userId"/>
<result column="filepath" property="filepath"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Notice">
insert into tb_notice(
title,
content,
create_time,
user_id,
filepath
)values(
#{title},
#{content},
now(),
#{userId},
#{filepath}
)
</insert>
<select id="query" resultMap="Notice">
select * from tb_notice
<include refid="NoticeFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_notice
<include refid="NoticeFindCriteria"/>
</select>
<select id="detail" resultMap="Notice">
select * from tb_notice where id = #{id}
</select>
<delete id="delete">
delete from tb_notice where id = #{id}
</delete>
<update id="update">
update tb_notice set
title=#{title},
content=#{content},
create_time=#{createTime},
user_id=#{userId},
filepath=#{filepath}
where id = #{id}
</update>
<update id="updateSelective">
update tb_notice
<set>
<if test="title != null and title != ''"> title = #{title},</if>
<if test="content != null and content != ''"> content = #{content},</if>
<if test="createTime != null and createTime != ''"> create_time = #{createTime},</if>
<if test="userId != null">user_id = #{userId},</if>
<if test="filepath != null and filepath != ''"> filepath = #{filepath},</if>
</set>
where id = #{id}
</update>
<sql id="NoticeFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="title != null and title != ''">and title = #{title}</if>
<if test="content != null and content != ''">and content = #{content}</if>
<if test="userId != null">and user_id = #{userId}</if>
<if test="filepath != null and filepath != ''">and filepath = #{filepath}</if>
</where>
</sql>
<select id="queryByBuildingId" resultMap="Notice">
select tb_notice.* from tb_notice,tb_notice_receive where tb_notice.id = tb_notice_receive.notice_id and building_id = #{buildingId}
<include refid="NoticeFindCriteria"/>
</select>
</mapper>

@ -0,0 +1,26 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入List集合类
import java.util.Map; // 导入Map集合类
import com.yanzhen.entity.NoticeReceive; // 导入NoticeReceive实体类
// 定义NoticeReceiveMapper接口
public interface NoticeReceiveMapper {
// 创建记录的方法
public int create(NoticeReceive noticeReceive);
// 根据ID删除记录的方法
public int delete(Integer id);
// 根据通知ID删除记录的方法并返回
public int deleteByNoticeId(Integer noticeId);
// 更新记录的方法
public int update(NoticeReceive noticeReceive);
// 选择性更新记录的方法
public int updateSelective(NoticeReceive noticeReceive);
// 查询记录列表的方法
public List<NoticeReceive> query(NoticeReceive noticeReceive);
// 根据ID获取NoticeReceive详情的方法
public NoticeReceive detail(Integer id);
// 统计NoticeReceive记录数量的方法
public int count(NoticeReceive noticeReceive);
}

@ -0,0 +1,65 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.NoticeReceiveMapper">
<resultMap type="com.yanzhen.entity.NoticeReceive" id="NoticeReceive">
<id column="id" property="id"/>
<result column="notice_id" property="noticeId"/>
<result column="building_id" property="buildingId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.NoticeReceive">
insert into tb_notice_receive(
notice_id,
building_id
)values(
#{noticeId},
#{buildingId}
)
</insert>
<select id="query" resultMap="NoticeReceive">
select * from tb_notice_receive
<include refid="NoticeReceiveFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_notice_receive
<include refid="NoticeReceiveFindCriteria"/>
</select>
<select id="detail" resultMap="NoticeReceive">
select * from tb_notice_receive where id = #{id}
</select>
<delete id="delete">
delete from tb_notice_receive where id = #{id}
</delete>
<delete id="deleteByNoticeId">
delete from tb_notice_receive where notice_id = #{noticeId}
</delete>
<update id="update">
update tb_notice_receive set
notice_id=#{noticeId},
building_id=#{buildingId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_notice_receive set
<if test="noticeId != null">notice_id = #{noticeId}</if>,
<if test="buildingId != null">building_id = #{buildingId}</if>
where id = #{id}
</update>
<sql id="NoticeReceiveFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="noticeId != null">and notice_id = #{noticeId}</if>
<if test="buildingId != null">and building_id = #{buildingId}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,28 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Org; // 导入Org实体类用于操作组织信息
// 定义OrgMapper接口
public interface OrgMapper {
// 创建一个新的Org记录返回影响的行数
public int create(Org org);
// 根据id删除一个Org记录
public int delete(Integer id);
// 更新一个Org记录
public int update(Org org);
// 选择性地更新一个Org记录
public int updateSelective(Org org);
// 根据条件查询Org的记录返回符合条件的Org列表
public List<Org> query(Org org);
// 根据id查询一个Org记录的详细信息返回Org的对象
public Org detail(Integer id);
// 根据条件统计出Org记录的数量
public int count(Org org);
// 根据selectionId查询相关的Org记录
public List<Org> queryOrgBySelectionId(Integer selectionId);
}

@ -0,0 +1,82 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.OrgMapper">
<resultMap type="com.yanzhen.entity.Org" id="Org">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="type" property="type"/>
<result column="grade_id" property="gradeId"/>
<result column="parent_id" property="parentId"/>
<result column="remark" property="remark"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Org">
insert into tb_org(
name,
type,
grade_id,
parent_id,
remark
)values(
#{name},
#{type},
#{gradeId},
#{parentId},
#{remark}
)
</insert>
<select id="query" resultMap="Org">
select * from tb_org
<include refid="OrgFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_org
<include refid="OrgFindCriteria"/>
</select>
<select id="detail" resultMap="Org">
select * from tb_org where id = #{id}
</select>
<delete id="delete">
delete from tb_org where id = #{id}
</delete>
<update id="update">
update tb_org set
name=#{name},
type=#{type},
grade_id=#{gradeId},
parent_id=#{parentId},
remark=#{remark}
where id = #{id}
</update>
<update id="updateSelective">
update tb_org set
<if test="name != null and name != ''"> name = #{name}</if>,
<if test="type != null">type = #{type}</if>,
<if test="gradeId != null">grade_id = #{gradeId}</if>,
<if test="parentId != null">parent_id = #{parentId}</if>,
<if test="remark != null and remark != ''"> remark = #{remark}</if>
where id = #{id}
</update>
<sql id="OrgFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="name != null and name != ''">and name = #{name}</if>
<if test="type != null">and type = #{type}</if>
<if test="gradeId != null">and grade_id = #{gradeId}</if>
<if test="parentId != null">and parent_id = #{parentId}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
</where>
</sql>
<select id="queryOrgBySelectionId" resultMap="Org">
select tb_org.* from tb_org,tb_selection_joiner where tb_selection_joiner.clazz_id = tb_org.id and selection_id = #{selectionId}
</select>
</mapper>

@ -0,0 +1,27 @@
// 定义包名表示该接口属于com.yanzhen.mapper包
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Record; // 导入Record实体类用于操作记录信息
// 定义RecordMapper接口
public interface RecordMapper {
// 创建一个Record记录返回影响的行数
public int create(Record record);
// 根据id删除一个Record记录
public int delete(Integer id);
// 更新一个Record记录
public int update(Record record);
// 选择性地更新一个Record记录
public int updateSelective(Record record);
// 根据设置条件查询Record记录返回符合条件的Record列表
public List<Record> query(Record record);
// 根据id查询一个Record记录的详细信息
public Record detail(Integer id);
// 根据条件统计Record记录的数量返回记录数量
public int count(Record record);
}

@ -0,0 +1,77 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.RecordMapper">
<resultMap type="com.yanzhen.entity.Record" id="Record">
<id column="id" property="id"/>
<result column="student_id" property="studentId"/>
<result column="dormitory_id" property="dormitoryId"/>
<result column="bed_id" property="bedId"/>
<result column="status" property="status"/>
<result column="create_date" property="createDate"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Record">
insert into tb_record(
student_id,
dormitory_id,
bed_id,
status,
create_date
)values(
#{studentId},
#{dormitoryId},
#{bedId},
#{status},
#{createDate}
)
</insert>
<select id="query" resultMap="Record">
select * from tb_record
<include refid="RecordFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_record
<include refid="RecordFindCriteria"/>
</select>
<select id="detail" resultMap="Record">
select * from tb_record where id = #{id}
</select>
<delete id="delete">
delete from tb_record where id = #{id}
</delete>
<update id="update">
update tb_record set
student_id=#{studentId},
dormitory_id=#{dormitoryId},
bed_id=#{bedId},
status=#{status},
create_date=#{createDate}
where id = #{id}
</update>
<update id="updateSelective">
update tb_record set
<if test="studentId != null">student_id = #{studentId}</if>,
<if test="dormitoryId != null">dormitory_id = #{dormitoryId}</if>,
<if test="bedId != null">bed_id = #{bedId}</if>,
<if test="status != null">status = #{status}</if>,
<if test="createDate != null and createDate != ''"> create_date = #{createDate}</if>
where id = #{id}
</update>
<sql id="RecordFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="studentId != null">and student_id = #{studentId}</if>
<if test="dormitoryId != null">and dormitory_id = #{dormitoryId}</if>
<if test="bedId != null">and bed_id = #{bedId}</if>
<if test="status != null">and status = #{status}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,27 @@
// 定义包名表示该接口属于com.yanzhen.mapper包
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Repair; // 导入Repair实体类用于操作维修记录信息
// 定义RepairMapper接口
public interface RepairMapper {
// 创建一个Repair记录返回影响的行数
public int create(Repair repair);
// 根据id删除Repair记录
public int delete(Integer id);
// 更新Repair记录
public int update(Repair repair);
// 选择性地更新Repair记录
public int updateSelective(Repair repair);
// 查询满足的Repair记录返回符合条件的Repair列表
public List<Repair> query(Repair repair);
// 根据id查询Repair记录的详细信息
public Repair detail(Integer id);
// 根据条件统计Repair记录的数量
public int count(Repair repair);
}

@ -0,0 +1,85 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.RepairMapper">
<resultMap type="com.yanzhen.entity.Repair" id="Repair">
<id column="id" property="id"/>
<result column="student_id" property="studentId"/>
<result column="dormitory_id" property="dormitoryId"/>
<result column="building_id" property="buildingId"/>
<result column="description" property="description"/>
<result column="create_date" property="createDate"/>
<result column="status" property="status"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Repair">
insert into tb_repair(
student_id,
dormitory_id,
building_id,
description,
create_date,
status
)values(
#{studentId},
#{dormitoryId},
#{buildingId},
#{description},
#{createDate},
#{status}
)
</insert>
<select id="query" resultMap="Repair">
select * from tb_repair
<include refid="RepairFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_repair
<include refid="RepairFindCriteria"/>
</select>
<select id="detail" resultMap="Repair">
select * from tb_repair where id = #{id}
</select>
<delete id="delete">
delete from tb_repair where id = #{id}
</delete>
<update id="update">
update tb_repair set
student_id=#{studentId},
dormitory_id=#{dormitoryId},
building_id=#{buildingId},
description=#{description},
create_date=#{createDate},
status=#{status}
where id = #{id}
</update>
<update id="updateSelective">
update tb_repair
<set>
<if test="studentId != null">student_id = #{studentId},</if>
<if test="dormitoryId != null">dormitory_id = #{dormitoryId},</if>
<if test="buildingId != null">building_id = #{buildingId},</if>
<if test="description != null and description != ''"> description = #{description},</if>
<if test="createDate != null and createDate != ''"> create_date = #{createDate},</if>
<if test="status != null">status = #{status},</if>
</set>
where id = #{id}
</update>
<sql id="RepairFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="studentId != null">and student_id = #{studentId}</if>
<if test="dormitoryId != null">and dormitory_id = #{dormitoryId}</if>
<if test="buildingId != null">and building_id = #{buildingId}</if>
<if test="description != null and description != ''">and description = #{description}</if>
<if test="status != null">and status = #{status}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,26 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.SelectionDormitory; // 导入SelectionDormitory实体类用于操作宿舍选择信息
// 定义SelectionDormitoryMapper接口
public interface SelectionDormitoryMapper {
// 创建SelectionDormitory记录
public int create(SelectionDormitory selectionDormitory);
// 根据id删除一个记录
public int delete(Integer id);
// 根据clazzId删除记录
public int deleteByClazzId(Integer clazzId);
// 更新一个记录
public int update(SelectionDormitory selectionDormitory);
// 选择性地更新一个记录
public int updateSelective(SelectionDormitory selectionDormitory);
// 根据条件查询记录
public List<SelectionDormitory> query(SelectionDormitory selectionDormitory);
// 根据id查询一个记录的详细信息
public SelectionDormitory detail(Integer id);
// 根据条件统计记录的数量
public int count(SelectionDormitory selectionDormitory);
}

@ -0,0 +1,64 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.SelectionDormitoryMapper">
<resultMap type="com.yanzhen.entity.SelectionDormitory" id="SelectionDormitory">
<id column="id" property="id"/>
<result column="dormitory_id" property="dormitoryId"/>
<result column="clazz_id" property="clazzId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.SelectionDormitory">
insert into tb_selection_dormitory(
dormitory_id,
clazz_id
)values(
#{dormitoryId},
#{clazzId}
)
</insert>
<select id="query" resultMap="SelectionDormitory">
select * from tb_selection_dormitory
<include refid="SelectionDormitoryFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_selection_dormitory
<include refid="SelectionDormitoryFindCriteria"/>
</select>
<select id="detail" resultMap="SelectionDormitory">
select * from tb_selection_dormitory where id = #{id}
</select>
<delete id="delete">
delete from tb_selection_dormitory where id = #{id}
</delete>
<update id="update">
update tb_selection_dormitory set
dormitory_id=#{dormitoryId},
clazz_id=#{clazzId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_selection_dormitory set
<if test="dormitoryId != null">dormitory_id = #{dormitoryId}</if>,
<if test="clazzId != null">clazz_id = #{clazzId}</if>
where id = #{id}
</update>
<sql id="SelectionDormitoryFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="dormitoryId != null">and dormitory_id = #{dormitoryId}</if>
<if test="clazzId != null">and clazz_id = #{clazzId}</if>
</where>
</sql>
<delete id="deleteByClazzId">
delete from tb_selection_dormitory where clazz_id = #{clazzId}
</delete>
</mapper>

@ -0,0 +1,26 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.SelectionJoiner; // 导入SelectionJoiner实体类用于操作宿舍层信息
// 定义SelectionJoinerMapper接口
public interface SelectionJoinerMapper {
// 创建一个新的SelectionJoiner记录
public int create(SelectionJoiner selectionJoiner);
// 删除一个记录
public int delete(Integer id);
// 根据selectionId删除记录
public int deleteBySelectionId(Integer selectionId);
// 更新一个记录
public int update(SelectionJoiner selectionJoiner);
// 选择性地更新一个记录
public int updateSelective(SelectionJoiner selectionJoiner);
// 查询记录
public List<SelectionJoiner> query(SelectionJoiner selectionJoiner);
// 查询一个记录的详细信息
public SelectionJoiner detail(Integer id);
// 统计记录的数量
public int count(SelectionJoiner selectionJoiner);
}

@ -0,0 +1,65 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.SelectionJoinerMapper">
<resultMap type="com.yanzhen.entity.SelectionJoiner" id="SelectionJoiner">
<id column="id" property="id"/>
<result column="selection_id" property="selectionId"/>
<result column="clazz_id" property="clazzId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.SelectionJoiner">
insert into tb_selection_joiner(
selection_id,
clazz_id
)values(
#{selectionId},
#{clazzId}
)
</insert>
<select id="query" resultMap="SelectionJoiner">
select * from tb_selection_joiner
<include refid="SelectionJoinerFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_selection_joiner
<include refid="SelectionJoinerFindCriteria"/>
</select>
<select id="detail" resultMap="SelectionJoiner">
select * from tb_selection_joiner where id = #{id}
</select>
<delete id="delete">
delete from tb_selection_joiner where id = #{id}
</delete>
<update id="update">
update tb_selection_joiner set
selection_id=#{selectionId},
clazz_id=#{clazzId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_selection_joiner set
<if test="selectionId != null">selection_id = #{selectionId}</if>,
<if test="clazzId != null">clazz_id = #{clazzId}</if>
where id = #{id}
</update>
<sql id="SelectionJoinerFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="selectionId != null">and selection_id = #{selectionId}</if>
<if test="clazzId != null">and clazz_id = #{clazzId}</if>
</where>
</sql>
<delete id="deleteBySelectionId">
delete from tb_selection_joiner where selection_id = #{selectionId}
</delete>
</mapper>

@ -0,0 +1,27 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Selection; // 导入Selection实体类用于操作选择信息
// 定义SelectionMapper接口
public interface SelectionMapper {
// 创建一个新的Selection记录
public int create(Selection selection);
// 删除一个Selection记录
public int delete(Integer id);
// 更新一个Selection记录
public int update(Selection selection);
// 选择性地更新一个Selection记录
public int updateSelective(Selection selection);
//查询Selection记录
public List<Selection> query(Selection selection);
// 查询Selection记录
public List<Selection> queryByClazzId(Integer clazzId);
// 查询一个Selection记录的详细信息
public Selection detail(Integer id);
// 统计Selection记录的数量
public int count(Selection selection);
}

@ -0,0 +1,75 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.SelectionMapper">
<resultMap type="com.yanzhen.entity.Selection" id="Selection">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="start_time" property="startTime"/>
<result column="end_time" property="endTime"/>
<result column="remark" property="remark"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Selection">
insert into tb_selection(
name,
start_time,
end_time,
remark
)values(
#{name},
#{startTime},
#{endTime},
#{remark}
)
</insert>
<select id="query" resultMap="Selection">
select * from tb_selection
<include refid="SelectionFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_selection
<include refid="SelectionFindCriteria"/>
</select>
<select id="detail" resultMap="Selection">
select * from tb_selection where id = #{id}
</select>
<delete id="delete">
delete from tb_selection where id = #{id}
</delete>
<update id="update">
update tb_selection set
name=#{name},
start_time=#{startTime},
end_time=#{endTime},
remark=#{remark}
where id = #{id}
</update>
<update id="updateSelective">
update tb_selection set
<if test="name != null and name != ''"> name = #{name}</if>,
<if test="startTime != null and startTime != ''"> start_time = #{startTime}</if>,
<if test="endTime != null and endTime != ''"> end_time = #{endTime}</if>,
<if test="remark != null and remark != ''"> remark = #{remark}</if>
where id = #{id}
</update>
<sql id="SelectionFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="name != null and name != ''">and name = #{name}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
</where>
</sql>
<select id="queryByClazzId" resultMap="Selection">
select tb_selection.* from tb_selection,tb_selection_joiner where tb_selection.id = tb_selection_joiner.selection_id
and clazz_id = #{clazzId} order by start_time desc limit 1
</select>
</mapper>

@ -0,0 +1,24 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Storey; // 导入Storey实体类用于操作宿舍层信息
// 定义StoreyMapper接口
public interface StoreyMapper {
// 创建一个新的Storey记录
public int create(Storey storey);
// 删除一个Storey记录
public int delete(Integer id);
// 更新一个Storey记录
public int update(Storey storey);
// 选择性地更新一个Storey记录
public int updateSelective(Storey storey);
// 查询Storey记录
public List<Storey> query(Storey storey);
// 查询一个Storey记录的详细信息
public Storey detail(Integer id);
// 统计Storey记录的数量
public int count(Storey storey);
}

@ -0,0 +1,66 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.StoreyMapper">
<resultMap type="com.yanzhen.entity.Storey" id="Storey">
<id column="id" property="id"/>
<result column="name" property="name"/>
<result column="building_id" property="buildingId"/>
<result column="remark" property="remark"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Storey">
insert into tb_storey(
name,
building_id,
remark
)values(
#{name},
#{buildingId},
#{remark}
)
</insert>
<select id="query" resultMap="Storey">
select * from tb_storey
<include refid="StoreyFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_storey
<include refid="StoreyFindCriteria"/>
</select>
<select id="detail" resultMap="Storey">
select * from tb_storey where id = #{id}
</select>
<delete id="delete">
delete from tb_storey where id = #{id}
</delete>
<update id="update">
update tb_storey set
name=#{name},
building_id=#{buildingId},
remark=#{remark}
where id = #{id}
</update>
<update id="updateSelective">
update tb_storey set
<if test="name != null and name != ''"> name = #{name}</if>,
<if test="buildingId != null">building_id = #{buildingId}</if>,
<if test="remark != null and remark != ''"> remark = #{remark}</if>
where id = #{id}
</update>
<sql id="StoreyFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="name != null and name != ''">and name = #{name}</if>
<if test="buildingId != null">and building_id = #{buildingId}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
</where>
</sql>
</mapper>

@ -0,0 +1,28 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.Student; // 导入Student实体类用于操作学生信息
// 定义一个StudentMapper公共接口
public interface StudentMapper {
// 创建学生记录
public int create(Student student);
//删除学生记录
public int delete(Integer id);
// 更新学生记录
public int update(Student student);
// 选择性更新学生记录
public int updateSelective(Student student);
// 查询学生记录
public List<Student> query(Student student);
// 定义一个获取学生详细信息的方法
public Student detail(Integer id);
// 通过名字获取学生详细信息
public Student detailByName(String name);
// 定义一个统计学生数量的方法
public int count(Student student);
// 定义一个登录方法返回值为Student对象参数为用户名称和密码
public Student login(String userName,String password);
}

@ -0,0 +1,106 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.StudentMapper">
<resultMap type="com.yanzhen.entity.Student" id="Student">
<id column="id" property="id"/>
<result column="stu_no" property="stuNo"/>
<result column="name" property="name"/>
<result column="idcard" property="idcard"/>
<result column="grade_id" property="gradeId"/>
<result column="sex" property="sex"/>
<result column="phone" property="phone"/>
<result column="password" property="password"/>
<result column="clazz_id" property="clazzId"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Student">
insert into tb_student(
stu_no,
name,
idcard,
grade_id,
sex,
phone,
password,
clazz_id
)values(
#{stuNo},
#{name},
#{idcard},
#{gradeId},
#{sex},
#{phone},
'123456',
#{clazzId}
)
</insert>
<select id="query" resultMap="Student">
select * from tb_student
<include refid="StudentFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_student
<include refid="StudentFindCriteria"/>
</select>
<select id="detail" resultMap="Student">
select * from tb_student where id = #{id}
</select>
<select id="detailByName" resultMap="Student">
select * from tb_student where name = #{name}
</select>
<delete id="delete">
delete from tb_student where id = #{id}
</delete>
<update id="update">
update tb_student set
stu_no=#{stuNo},
name=#{name},
idcard=#{idcard},
grade_id=#{gradeId},
sex=#{sex},
phone=#{phone},
password=#{password},
clazz_id=#{clazzId}
where id = #{id}
</update>
<update id="updateSelective">
update tb_student
<set>
<if test="stuNo != null and stuNo != ''"> stu_no = #{stuNo},</if>
<if test="name != null and name != ''"> name = #{name},</if>
<if test="idcard != null and idcard != ''"> idcard = #{idcard},</if>
<if test="gradeId != null">grade_id = #{gradeId},</if>
<if test="sex != null">sex = #{sex},</if>
<if test="phone != null and phone != ''"> phone = #{phone},</if>
<if test="password != null and password != ''"> password = #{password},</if>
<if test="clazzId != null">clazz_id = #{clazzId},</if>
</set>
where id = #{id}
</update>
<sql id="StudentFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="stuNo != null and stuNo != ''">and stu_no = #{stuNo}</if>
<if test="name != null and name != ''">and name like concat('%',#{name},'%') </if>
<if test="idcard != null and idcard != ''">and idcard = #{idcard}</if>
<if test="gradeId != null">and grade_id = #{gradeId}</if>
<if test="sex != null">and sex = #{sex}</if>
<if test="phone != null and phone != ''">and phone = #{phone}</if>
<if test="password != null and password != ''">and password = #{password}</if>
<if test="clazzId != null">and clazz_id = #{clazzId}</if>
</where>
</sql>
<select id="login" resultMap="Student">
select * from tb_student where stu_no = #{userName} and password = #{password}
</select>
</mapper>

@ -0,0 +1,27 @@
// 定义包名
package com.yanzhen.mapper;
import java.util.List; // 导入Java的List类用于处理列表数据结构
import java.util.Map; // 导入Java的Map类用于处理键值对数据结构
import com.yanzhen.entity.User; // 导入User实体类用于操作用户数据
import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解用于传递参数到SQL语句中
// 定义UserMapper接口
public interface UserMapper {
// 定义create方法创建新用户
public int create(User user);
// 根据用户ID删除用户
public int delete(Integer id);
// 更新用户信息
public int update(User user);
// 选择性更新用户信息
public int updateSelective(User user);
//查询用户列表
public List<User> query(User user);
// 查询用户详情
public User detail(Integer id);
//查询用户
public User login(@Param("userName") String userName, @Param("password") String password);
// 统计符合条件的用户数量
public int count(User user);
}

@ -0,0 +1,90 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.UserMapper">
<resultMap type="com.yanzhen.entity.User" id="User">
<id column="id" property="id"/>
<result column="user_name" property="userName"/>
<result column="password" property="password"/>
<result column="name" property="name"/>
<result column="phone" property="phone"/>
<result column="type" property="type"/>
<result column="remark" property="remark"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.User">
insert into tb_user(
user_name,
password,
name,
phone,
type,
remark
)values(
#{userName},
#{password},
#{name},
#{phone},
#{type},
#{remark}
)
</insert>
<select id="query" resultMap="User">
select * from tb_user
<include refid="UserFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_user
<include refid="UserFindCriteria"/>
</select>
<select id="detail" resultMap="User">
select * from tb_user where id = #{id}
</select>
<delete id="delete">
delete from tb_user where id = #{id}
</delete>
<update id="update">
update tb_user set
user_name=#{userName},
password=#{password},
name=#{name},
phone=#{phone},
type=#{type},
remark=#{remark}
where id = #{id}
</update>
<update id="updateSelective">
update tb_user
<set>
<if test="userName != null and userName != ''"> user_name = #{userName},</if>
<if test="password != null and password != ''"> password = #{password},</if>
<if test="name != null and name != ''"> name = #{name},</if>
<if test="phone != null and phone != ''"> phone = #{phone},</if>
<if test="type != null">type = #{type},</if>
<if test="remark != null and remark != ''"> remark = #{remark},</if>
</set>
where id = #{id}
</update>
<sql id="UserFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="userName != null and userName != ''">and user_name like concat('%',#{userName},'%') </if>
<if test="password != null and password != ''">and password = #{password}</if>
<if test="name != null and name != ''">and name like concat('%',#{name},'%')</if>
<if test="phone != null and phone != ''">and phone = #{phone}</if>
<if test="type != null">and type = #{type}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
</where>
</sql>
<select id="login" resultMap="User">
select * from tb_user where user_name = #{userName} and password=#{password}
</select>
</mapper>

@ -0,0 +1,24 @@
package com.yanzhen.mapper;
import java.util.List; // 导入Java标准库中的List类
import java.util.Map; // 导入Java标准库中的Map类
import com.yanzhen.entity.Visit; // 导入自定义的Visit实体类
// 定义一个VisitMapper公共接口
public interface VisitMapper {
// 创建访问记录
public int create(Visit visit);
// 定义一个删除访问记录的方法
public int delete(Integer id);
// 定义一个更新访问记录的方法
public int update(Visit visit);
// 定义一个选择性更新访问记录的方法
public int updateSelective(Visit visit);
// 定义一个查询访问记录的方法
public List<Visit> query(Visit visit);
// 定义一个获取访问记录详情的方法
public Visit detail(Integer id);
// 定义一个统计访问记录数量的方法
public int count(Visit visit);
}

@ -0,0 +1,96 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yanzhen.mapper.VisitMapper">
<resultMap type="com.yanzhen.entity.Visit" id="Visit">
<id column="id" property="id"/>
<result column="visitor" property="visitor"/>
<result column="phone" property="phone"/>
<result column="sex" property="sex"/>
<result column="idcard" property="idcard"/>
<result column="student_id" property="studentId"/>
<result column="visit_time" property="visitTime"/>
<result column="leave_time" property="leaveTime"/>
<result column="remark" property="remark"/>
</resultMap>
<insert id="create" keyProperty="id" useGeneratedKeys="true" parameterType="com.yanzhen.entity.Visit">
insert into tb_visit(
visitor,
phone,
sex,
idcard,
student_id,
visit_time,
leave_time,
remark
)values(
#{visitor},
#{phone},
#{sex},
#{idcard},
#{studentId},
#{visitTime},
#{leaveTime},
#{remark}
)
</insert>
<select id="query" resultMap="Visit">
select * from tb_visit
<include refid="VisitFindCriteria"/>
</select>
<select id="count" resultType="int">
select count(1) from tb_visit
<include refid="VisitFindCriteria"/>
</select>
<select id="detail" resultMap="Visit">
select * from tb_visit where id = #{id}
</select>
<delete id="delete">
delete from tb_visit where id = #{id}
</delete>
<update id="update">
update tb_visit set
visitor=#{visitor},
phone=#{phone},
sex=#{sex},
idcard=#{idcard},
student_id=#{studentId},
visit_time=#{visitTime},
leave_time=#{leaveTime},
remark=#{remark}
where id = #{id}
</update>
<update id="updateSelective">
update tb_visit
<set>
<if test="visitor != null and visitor != ''"> visitor = #{visitor},</if>
<if test="phone != null and phone != ''"> phone = #{phone},</if>
<if test="sex != null">sex = #{sex},</if>
<if test="idcard != null and idcard != ''"> idcard = #{idcard},</if>
<if test="studentId != null">student_id = #{studentId},</if>
<if test="visitTime != null"> visit_time = #{visitTime},</if>
<if test="leaveTime != null"> leave_time = #{leaveTime},</if>
<if test="remark != null and remark != ''"> remark = #{remark},</if>
</set>
where id = #{id}
</update>
<sql id="VisitFindCriteria">
<where>
<if test="id != null">and id = #{id}</if>
<if test="visitor != null and visitor != ''">and visitor = #{visitor}</if>
<if test="phone != null and phone != ''">and phone = #{phone}</if>
<if test="sex != null">and sex = #{sex}</if>
<if test="idcard != null and idcard != ''">and idcard = #{idcard}</if>
<if test="studentId != null">and student_id = #{studentId}</if>
<if test="remark != null and remark != ''">and remark = #{remark}</if>
</where>
</sql>
</mapper>
Loading…
Cancel
Save