package cn.flightfeather.supervision.lightshare.web
|
|
import cn.flightfeather.supervision.domain.ds1.entity.*
|
import cn.flightfeather.supervision.common.utils.DateUtil
|
import cn.flightfeather.supervision.common.utils.UUIDGenerator
|
import cn.flightfeather.supervision.lightshare.service.*
|
import cn.flightfeather.supervision.lightshare.vo.*
|
import org.springframework.beans.BeanUtils
|
import org.springframework.beans.factory.annotation.Autowired
|
import org.springframework.stereotype.Controller
|
import org.springframework.ui.Model
|
import org.springframework.util.StringUtils
|
import org.springframework.validation.BindingResult
|
import org.springframework.web.bind.annotation.GetMapping
|
import org.springframework.web.bind.annotation.PostMapping
|
import org.springframework.web.bind.annotation.RequestMapping
|
import org.springframework.web.bind.annotation.ResponseBody
|
import springfox.documentation.annotations.ApiIgnore
|
import java.math.BigDecimal
|
import java.util.*
|
|
@ApiIgnore
|
@Controller
|
@RequestMapping("menu")
|
class MenuController {
|
@Autowired
|
lateinit var scenseService: ScenseService
|
|
@Autowired
|
lateinit var siteService: SiteService
|
|
@Autowired
|
lateinit var domaincatalogService: DomaincatalogService
|
|
@Autowired
|
lateinit var domainitemService: DomainitemService
|
|
@Autowired
|
lateinit var problemtypeService: ProblemtypeService
|
|
@Autowired
|
lateinit var problemlistService: ProblemlistService
|
|
@Autowired
|
lateinit var gitlistService: GitlistService
|
|
@Autowired
|
lateinit var gittypeService: GittypeService
|
|
@Autowired
|
lateinit var cityService: CityService
|
|
@Autowired
|
lateinit var provinceService: ProvinceService
|
|
@Autowired
|
lateinit var districtService: DistrictService
|
|
@Autowired
|
lateinit var mediafileService: MediafileService
|
|
@Autowired
|
lateinit var townService: TownService
|
|
@Autowired
|
lateinit var taskService: TaskService
|
|
@Autowired
|
lateinit var subtaskService: SubtaskService
|
|
@Autowired
|
lateinit var inspectionService: InspectionService
|
|
@Autowired
|
lateinit var userinfoService: UserinfoService
|
|
@Autowired
|
lateinit var evaluationruleService: EvaluationruleService
|
|
@Autowired
|
lateinit var monitorobjectversionService: MonitorobjectversionService
|
|
//监管版本管理页面
|
@GetMapping("/monitorobjectversion-list")
|
fun monitorobjectversionList(taskId: String, model: Model): String {
|
val list = monitorobjectversionService.findByTaskId(taskId)
|
model.addAttribute("monitorobjectversions", list)
|
model.addAttribute("taskId", taskId)
|
return "monitorobjectversion-list"
|
}
|
|
//监管版本新增页面
|
@GetMapping("/monitorobjectversion-add")
|
fun monitorobjectversionAdd(taskId: String, model: Model): String {
|
|
val monitorobjectversion = Monitorobjectversion()
|
val list = monitorobjectversionService.findByTaskId(taskId)
|
val scenseIds = mutableListOf<String>()
|
list.forEach {
|
scenseIds.add(it.sguid.toString())
|
}
|
val scense = scenseService.getUserByTaskId(scenseIds, taskId)
|
model.addAttribute("monitorobjectversion", monitorobjectversion)
|
model.addAttribute("taskId", taskId)
|
return "monitorobjectversion-add"
|
}
|
|
//考核规范管理页面
|
@GetMapping("/evaluationrule-list")
|
fun evaluationruleList(model: Model): String {
|
val list = evaluationruleService.findAll()
|
model.addAttribute("evaluationrules", list)
|
return "evaluationrule-list"
|
}
|
|
//考核规范新增页面
|
@GetMapping("/evaluationrule-add")
|
fun evaluationruleAdd(id: String, model: Model): String {
|
var evaluationrule = Evaluationrule()
|
if ("" != id.trim()) {
|
evaluationrule = evaluationruleService.findOne(id)
|
}
|
|
val tasktype = domainitemService.findByLogName("任务类型")
|
val scensetype = domainitemService.findByLogName("场景类型")
|
val scensesubtype = domainitemService.findByLogName("场景细分类型")
|
val ruletype = domainitemService.findByLogName("规范类别")
|
|
//获取所有省份
|
val processlist = provinceService.findAll()
|
//获取所有地市
|
val citylist = cityService.findAll()
|
//获取所有区县
|
val districtlist = districtService.findAll()
|
//获取所有街镇
|
val townlist = townService.findAll()
|
|
model.addAttribute("processlist", processlist)
|
model.addAttribute("citylist", citylist)
|
model.addAttribute("districtlist", districtlist)
|
model.addAttribute("townlist", townlist)
|
model.addAttribute("tasktypes", tasktype)
|
model.addAttribute("scensetypes", scensetype)
|
model.addAttribute("scensesubtypes", scensesubtype)
|
model.addAttribute("ruletypes", ruletype)
|
model.addAttribute("evaluationrule", evaluationrule)
|
return "evaluationrule-add"
|
}
|
|
//考核规范新增处理
|
@PostMapping("/evaluationrule-add")
|
@ResponseBody
|
fun evaluationruleAddDo(evaluationrule: Evaluationrule, bindingResult: BindingResult): String {
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(evaluationrule.guid)) {
|
evaluationruleService.update(evaluationrule)
|
} else {
|
evaluationrule.guid = UUIDGenerator.generate16ShortUUID()
|
evaluationruleService.save(evaluationrule)
|
}
|
//值域类型存在不进行任何处理
|
//都跳转到新增页面
|
return "success"
|
}
|
|
|
//巡查管理页面
|
@GetMapping("/inspection-list")
|
fun inspectionList(model: Model): String {
|
val list = inspectionService.findAll()
|
model.addAttribute("inspections", list)
|
return "inspection-list"
|
}
|
|
//巡查查看页面
|
@GetMapping("/inspection-show")
|
fun inspectionShow(id: String, model: Model): String {
|
|
val inspection = inspectionService.findByID(id)
|
model.addAttribute("inspection", inspection)
|
return "inspection-show"
|
}
|
|
//巡查问题查看页面
|
@GetMapping("/problemlist-show")
|
fun problemlistShow(id: String, model: Model): String {
|
|
val problemlistVo = problemlistService.findByID(id)
|
val mediafileVos = mediafileService.findByBusinessGUID(id)
|
model.addAttribute("problemlist", problemlistVo)
|
model.addAttribute("mediafileVos", mediafileVos)
|
return "problemlist-show"
|
}
|
//problemtype-add
|
|
|
//巡查技防措施列表页面
|
@GetMapping("/gitlist-list")
|
fun gitlistList(inspectionId: String, model: Model): String {
|
val list = gitlistService.findByInspectionID(inspectionId)
|
model.addAttribute("gitlists", list)
|
return "gitlist-list"
|
}
|
|
//巡查问题列表页面
|
@GetMapping("/problemlist-list")
|
fun problemlistList(inspectionId: String, model: Model): String {
|
val list = problemlistService.findByInspectionID(inspectionId)
|
model.addAttribute("problemlists", list)
|
return "problemlist-list"
|
}
|
|
//任务管理页面
|
@GetMapping("/task-list")
|
fun taskList(model: Model): String {
|
|
val list = taskService.getAllTop()
|
model.addAttribute("tasks", list)
|
return "task-list"
|
}
|
|
//任务管理页面
|
@GetMapping("/taskday-list")
|
fun taskdayList(taskId: String, model: Model): String {
|
val list = taskService.getDayTaskByTaskID(taskId)
|
model.addAttribute("tasks", list)
|
model.addAttribute("taskId", taskId)
|
return "taskday-list"
|
}
|
|
//子任务管理页面
|
@GetMapping("/subtask-list")
|
fun subtaskList(taskId: String, taskdayId: String, model: Model): String {
|
val list = subtaskService.findByDayTaskID(taskdayId)
|
model.addAttribute("subtasks", list)
|
model.addAttribute("taskdayId", taskdayId)
|
model.addAttribute("taskId", taskId)
|
return "subtask-list"
|
}
|
|
//子任务添加页面
|
@GetMapping("/subtask-add")
|
fun subtaskdayAdd(taskId: String, taskdayId: String, id: String, model: Model): String {
|
var subtaskVo = SubtaskVo()
|
if (!StringUtils.isEmpty(id)) {
|
subtaskVo = subtaskService.findByID(id)
|
val planstarttime = subtaskVo.planstarttime
|
val planendtime = subtaskVo.planendtime
|
if (planstarttime != null) {
|
subtaskVo.planstarttimestr = DateUtil.DateToString(planstarttime, "yyyy-MM-dd")
|
}
|
if (planendtime != null) {
|
subtaskVo.planendtimestr = DateUtil.DateToString(planendtime, "yyyy-MM-dd")
|
}
|
}
|
val taskdayVolist = taskService.getDayTaskByTaskID(taskId)
|
//过滤为发布的 未发布的顶层任务不允许条件日任务
|
//val subtask = taskVolist.filter { it.deploytime != null }
|
model.addAttribute("taskdayVolist", taskdayVolist)
|
//顶级任务ID
|
model.addAttribute("taskid", taskId)
|
model.addAttribute("subtaskVo", subtaskVo)
|
model.addAttribute("taskdayId", taskdayId)
|
return "subtask-add"
|
}
|
|
//任务新增请求处理
|
@PostMapping("/subtask-add")
|
@ResponseBody
|
fun subtaskAddDo(subtaskVo: SubtaskVo): String {
|
val subtask = Subtask()
|
BeanUtils.copyProperties(subtaskVo, subtask)
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(subtask.stguid)) {
|
subtaskService.changeStatus(subtask)
|
} else {
|
//获取日任务
|
val daytask = taskService.findByID(subtaskVo.tsguid!!)
|
BeanUtils.copyProperties(daytask, subtask)
|
subtask.stguid = UUIDGenerator.generate16ShortUUID()
|
subtask.type = daytask.typename
|
subtask.tsguid = subtaskVo.tsguid
|
subtask.planstarttime = daytask.starttime
|
subtask.planendtime = daytask.endtime
|
subtask.deploytime = null
|
}
|
|
subtaskService.save(subtask)
|
|
//都跳转到新增页面
|
return "success"
|
}
|
|
//子任务展示页面页面
|
@GetMapping("/subtask-show")
|
fun subtaskShow(taskId: String, model: Model): String {
|
val list = subtaskService.findByTaskID(taskId)
|
model.addAttribute("subtasks", list)
|
return "subtask-show"
|
}
|
|
//任务添加页面
|
@GetMapping("/task-add")
|
fun taskAdd(id: String, model: Model): String {
|
var taskVo = TaskVo()
|
if (!StringUtils.isEmpty(id)) {
|
taskVo = taskService.findByID(id)
|
val starttime = taskVo.starttime
|
val endtime = taskVo.endtime
|
if (starttime != null) {
|
taskVo.starttimestr = DateUtil.DateToString(starttime, "yyyy-MM-dd")
|
}
|
if (endtime != null) {
|
taskVo.endtimestr = DateUtil.DateToString(endtime, "yyyy-MM-dd")
|
}
|
|
}
|
//获取所有省份
|
val processlist = provinceService.findAll()
|
//获取所有地市
|
val citylist = cityService.findAll()
|
//获取所有区县
|
val districtlist = districtService.findAll()
|
//获取所有街镇
|
val townlist = townService.findAll()
|
|
val typename = domainitemService.findByLogName("任务类型")
|
val deadlinetype = domainitemService.findByLogName("任务期限类型")
|
|
val userinfo = userinfoService.findAll()
|
|
model.addAttribute("userinfos", userinfo)
|
model.addAttribute("processlist", processlist)
|
model.addAttribute("citylist", citylist)
|
model.addAttribute("districtlist", districtlist)
|
model.addAttribute("townlist", townlist)
|
model.addAttribute("typenames", typename)
|
model.addAttribute("deadlinetypes", deadlinetype)
|
model.addAttribute("taskVo", taskVo)
|
return "task-add"
|
}
|
|
//日任务添加页面
|
@GetMapping("/taskday-add")
|
fun taskdayAdd(taskid: String, id: String, model: Model): String {
|
var taskVo = TaskVo()
|
if (!StringUtils.isEmpty(id)) {
|
taskVo = taskService.findByID(id)
|
val starttime = taskVo.starttime
|
val endtime = taskVo.endtime
|
if (starttime != null) {
|
taskVo.starttimestr = DateUtil.DateToString(starttime, "yyyy-MM-dd")
|
}
|
if (endtime != null) {
|
taskVo.endtimestr = DateUtil.DateToString(endtime, "yyyy-MM-dd")
|
}
|
}
|
val taskVolist = taskService.findTopTask()
|
//过滤为发布的 未发布的顶层任务不允许条件日任务
|
//val subtask = taskVolist.filter { it.deploytime != null }
|
model.addAttribute("taskVolist", taskVolist)
|
model.addAttribute("taskVo", taskVo)
|
//顶级任务ID
|
model.addAttribute("taskid", taskid)
|
return "taskday-add"
|
}
|
|
//任务新增请求处理
|
@PostMapping("/task-add")
|
@ResponseBody
|
fun taskAddDo(taskVo: TaskVo): String {
|
val task = Task()
|
BeanUtils.copyProperties(taskVo, task)
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(task.tguid)) {
|
taskService.update(task)
|
} else {
|
val tsguid = taskVo.tsguid
|
if (tsguid != null) {
|
val starttimestr = taskVo.starttimestr ?: ""
|
if (starttimestr.length < 10) {
|
return ""
|
}
|
val staryear = taskVo.starttimestr!!.substring(0, 4)
|
val starmon = taskVo.starttimestr!!.substring(5, 7)
|
val starday = taskVo.starttimestr!!.substring(8, 10)
|
var taskname = "${staryear}年${starmon}月${starday}日"
|
val toptask = taskService.findByID(taskVo.tsguid!!)
|
if (toptask.tguid != null) {
|
taskname += toptask.cityname + toptask.districtname
|
taskname += if (!StringUtils.isEmpty(toptask.townname)) {
|
toptask.townname + toptask.typename
|
} else {
|
toptask.typename
|
}
|
toptask.tsguid = tsguid
|
toptask.name = taskname
|
//新赋值guid
|
toptask.tguid = UUIDGenerator.generate16ShortUUID()
|
//日期变化
|
toptask.starttime = DateUtil.StringToDate(starttimestr)
|
toptask.endtime = DateUtil.StringToDate(starttimestr)
|
//新建任务发布为null
|
toptask.deploytime = null
|
}
|
BeanUtils.copyProperties(toptask, task)
|
taskService.save(task)
|
} else {
|
if (taskVo.starttimestr!!.length < 10 || taskVo.endtimestr!!.length < 10) {
|
return ""
|
}
|
val staryear = taskVo.starttimestr!!.substring(0, 4)
|
val endyear = taskVo.endtimestr!!.substring(0, 4)
|
|
val starmon = taskVo.starttimestr!!.substring(5, 7)
|
val endmon = taskVo.endtimestr!!.substring(5, 7)
|
|
var taskname = if (staryear == endyear) {
|
if (starmon == endmon) {
|
"${staryear}年${starmon}月"
|
} else {
|
"${staryear}年${starmon}月-${endmon}月"
|
}
|
} else {
|
"${staryear}年${starmon}月-${endyear}年${endmon}月"
|
}
|
taskname += taskVo.cityname + taskVo.districtname
|
|
taskname += if (!StringUtils.isEmpty(taskVo.townname)) {
|
taskVo.townname + taskVo.typename
|
} else {
|
taskVo.typename
|
}
|
// val istask = taskService.findByName(taskname)
|
// if (istask.tguid != null) {
|
// return ""
|
// }
|
task.tguid = UUIDGenerator.generate16ShortUUID()
|
task.name = taskname
|
task.starttime = DateUtil.StringToDate(taskVo.starttimestr!!)
|
task.endtime = DateUtil.StringToDate(taskVo.endtimestr!!)
|
task.settime = Date()
|
taskService.save(task)
|
}
|
}
|
//都跳转到新增页面
|
return "success"
|
}
|
|
//场景管理页面
|
@GetMapping("/scense-list")
|
fun scenseList(scense: Scense, model: Model): String {
|
val list = scenseService.search(scense)
|
val scensetype = domainitemService.findByLogName("场景类型")
|
model.addAttribute("scenses", list)
|
model.addAttribute("scense", scense)
|
model.addAttribute("scensetypes", scensetype)
|
return "scense-list"
|
}
|
|
//场景添加页面
|
@GetMapping("/scense-add")
|
fun scenseAdd(id: String, model: Model): String {
|
var scenseVo = ScenseVo()
|
if ("" != id.trim()) {
|
scenseVo = scenseService.findOne(id)
|
}
|
|
//获取所有省份
|
val processlist = provinceService.findAll()
|
//获取所有地市
|
val citylist = cityService.findAll()
|
//获取所有区县
|
val districtlist = districtService.findAll()
|
//获取所有街镇
|
val townlist = townService.findAll()
|
|
val scensetype = domainitemService.findByLogName("场景类型")
|
|
val scensesubtype = domainitemService.findByLogName("场景细分类型")
|
|
model.addAttribute("processlist", processlist)
|
model.addAttribute("citylist", citylist)
|
model.addAttribute("districtlist", districtlist)
|
model.addAttribute("townlist", townlist)
|
model.addAttribute("scensetypes", scensetype)
|
model.addAttribute("scensesubtypes", scensesubtype)
|
model.addAttribute("scenseVo", scenseVo)
|
return "scense-add"
|
}
|
|
//场景添加页面
|
@PostMapping("/scense-add")
|
@ResponseBody
|
fun scenseAddDo(scense: Scense, bindingResult: BindingResult): String {
|
if (!StringUtils.isEmpty(scense.guid)) {
|
scenseService.update(scense)
|
} else {
|
val scenserere = scenseService.findByName(scense.name!!)
|
if (scenserere.guid == null) {
|
scense.guid = UUIDGenerator.generate16ShortUUID()
|
scenseService.save(scense)
|
}
|
}
|
return "success"
|
}
|
|
|
//工地管理页面
|
@GetMapping("/site-list")
|
fun siteList(site: Site, model: Model): String {
|
val list = siteService.search(site)
|
model.addAttribute("sites", list)
|
model.addAttribute("site", site)
|
return "site-list"
|
}
|
|
//工地添加页面
|
@GetMapping("/site-add")
|
fun siteAdd(id: String, model: Model): String {
|
var siteVo = SiteVo()
|
if (!StringUtils.isEmpty(id)) {
|
siteVo = siteService.findOne(id)
|
}
|
|
//获取所有省份
|
val processlist = provinceService.findAll()
|
//获取所有地市
|
val citylist = cityService.findAll()
|
//获取所有区县
|
val districtlist = districtService.findAll()
|
//获取所有街镇
|
val townlist = townService.findAll()
|
model.addAttribute("processlist", processlist)
|
model.addAttribute("citylist", citylist)
|
model.addAttribute("districtlist", districtlist)
|
model.addAttribute("townlist", townlist)
|
model.addAttribute("siteVo", siteVo)
|
return "site-add"
|
}
|
|
//工地新增请求处理
|
@PostMapping("/site-add")
|
@ResponseBody
|
fun siteAddDo(siteVo: Site): String {
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(siteVo.guid)) {
|
siteService.update(siteVo)
|
} else {
|
//如果guid为空
|
//根据新增值域类型名称查询
|
val isno = siteService.findOneByName(siteVo.name!!)
|
//如果该值域类型不存在,则新增
|
if (isno.guid == null) {
|
siteVo.guid = UUIDGenerator.generate16ShortUUID()
|
if (siteVo.sitelatitude != null) {
|
siteVo.sitelatitude = BigDecimal.valueOf(siteVo.sitelatitude!!.toDouble())
|
}
|
if (siteVo.sitelongitude !== null) {
|
siteVo.sitelongitude = BigDecimal.valueOf(siteVo.sitelongitude!!.toDouble())
|
}
|
siteService.save(siteVo)
|
} else {
|
return "failure"
|
}
|
//值域类型存在不进行任何处理
|
}
|
//都跳转到新增页面
|
return "success"
|
}
|
|
//技防措施类别管理->技防措施类别页面
|
@GetMapping("/gittype-list")
|
fun gittypelist(gittype: Gittype, model: Model): String {
|
val list = gittypeService.search(gittype)
|
val type = domainitemService.findByLogName("措施类别")
|
model.addAttribute("types", type)
|
model.addAttribute("gittype", gittype)
|
model.addAttribute("gittypes", list)
|
return "gittype-list"
|
}
|
|
//技防措施类别新增页面
|
@GetMapping("/gittype-add")
|
fun gittypeAdd(id: String, model: Model): String {
|
var gittype = Gittype()
|
if (!StringUtils.isEmpty(id)) {
|
gittype = gittypeService.findOne(id)
|
}
|
|
val tasktype = domainitemService.findByLogName("任务类型")
|
val scensetype = domainitemService.findByLogName("场景类型")
|
val typename = domainitemService.findByLogName("问题类别")
|
val scensesubtype = domainitemService.findByLogName("场景细分类型")
|
|
val type = domainitemService.findByLogName("措施类别")
|
|
//获取所有省份
|
val processlist = provinceService.findAll()
|
//获取所有地市
|
val citylist = cityService.findAll()
|
//获取所有区县
|
val districtlist = districtService.findAll()
|
//获取所有街镇
|
val townlist = townService.findAll()
|
|
model.addAttribute("processlist", processlist)
|
model.addAttribute("citylist", citylist)
|
model.addAttribute("districtlist", districtlist)
|
model.addAttribute("townlist", townlist)
|
model.addAttribute("types", type)
|
model.addAttribute("tasktypes", tasktype)
|
model.addAttribute("scensetypes", scensetype)
|
model.addAttribute("typenames", typename)
|
model.addAttribute("scensesubtypes", scensesubtype)
|
model.addAttribute("gittype", gittype)
|
return "gittype-add"
|
}
|
|
//问题类别新增处理
|
@PostMapping("/gittype-add")
|
@ResponseBody
|
fun gittypeAddDo(gittype: Gittype, bindingResult: BindingResult): String {
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(gittype.guid)) {
|
gittypeService.update(gittype)
|
} else {
|
gittype.guid = UUIDGenerator.generate16ShortUUID()
|
gittypeService.save(gittype)
|
}
|
//值域类型存在不进行任何处理
|
//都跳转到新增页面
|
return "success"
|
}
|
|
//问题管理->问题类别页面
|
@GetMapping("/problemtype-list")
|
fun problemtypelist(problemtype: Problemtype, model: Model): String {
|
val list = problemtypeService.search(problemtype)
|
val typename = domainitemService.findByLogName("问题类别")
|
model.addAttribute("typenames", typename)
|
model.addAttribute("problemtypes", list)
|
model.addAttribute("problemtype", problemtype)
|
return "problemtype-list"
|
}
|
|
|
//问题类别新增页面
|
@GetMapping("/problemtype-add")
|
fun problemtypeAdd(id: String, model: Model): String {
|
var problemtype = Problemtype()
|
if ("" != id.trim()) {
|
problemtype = problemtypeService.findOne(id)
|
}
|
val tasktype = domainitemService.findByLogName("任务类型")
|
val scensetype = domainitemService.findByLogName("场景类型")
|
val typename = domainitemService.findByLogName("问题类别")
|
val scensesubtype = domainitemService.findByLogName("场景细分类型")
|
|
//获取所有省份
|
val processlist = provinceService.findAll()
|
//获取所有地市
|
val citylist = cityService.findAll()
|
//获取所有区县
|
val districtlist = districtService.findAll()
|
//获取所有街镇
|
val townlist = townService.findAll()
|
|
model.addAttribute("processlist", processlist)
|
model.addAttribute("citylist", citylist)
|
model.addAttribute("districtlist", districtlist)
|
model.addAttribute("townlist", townlist)
|
model.addAttribute("problemtype", problemtype)
|
model.addAttribute("tasktypes", tasktype)
|
model.addAttribute("scensetypes", scensetype)
|
model.addAttribute("typenames", typename)
|
model.addAttribute("scensesubtypes", scensesubtype)
|
return "problemtype-add"
|
}
|
|
//问题类别新增处理
|
@PostMapping("/problemtype-add")
|
@ResponseBody
|
fun problemtypeAddDo(problemtype: Problemtype, bindingResult: BindingResult): String {
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(problemtype.guid)) {
|
problemtypeService.update(problemtype)
|
} else {
|
//如果guid为空
|
problemtype.guid = UUIDGenerator.generate16ShortUUID()
|
problemtypeService.save(problemtype)
|
}
|
//值域类型存在不进行任何处理
|
//都跳转到新增页面
|
return "success"
|
}
|
|
//值域表类型页面
|
@GetMapping("/domaincatalog-list")
|
fun domaincatalogList(model: Model): String {
|
val list = domaincatalogService.findAll()
|
model.addAttribute("domaincatalogs", list)
|
return "domaincatalog-list"
|
}
|
|
//值域表新增页面
|
@GetMapping("/domaincatalog-add")
|
fun domaincatalogAdd(id: String, model: Model): String {
|
var domaincatalog = Domaincatalog()
|
if ("" != id.trim()) {
|
domaincatalog = domaincatalogService.findOne(id)
|
}
|
model.addAttribute("domaincatalog", domaincatalog)
|
return "domaincatalog-add"
|
}
|
|
//值域表新增请求处理
|
@PostMapping("/domaincatalog-add")
|
fun domaincatalogAddDo(domaincatalog: Domaincatalog): String {
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(domaincatalog.guid)) {
|
domaincatalogService.update(domaincatalog)
|
} else {
|
//如果guid为空
|
//根据新增值域类型名称查询
|
val isno = domaincatalogService.findOneByName(domaincatalog.name!!)
|
//如果该值域类型不存在,则新增
|
if (isno == null) {
|
domaincatalog.guid = UUIDGenerator.generate16ShortUUID()
|
domaincatalogService.save(domaincatalog)
|
}
|
//值域类型存在不进行任何处理
|
}
|
//都跳转到新增页面
|
return "success"
|
}
|
|
//值域类型删除处理,返回已处理页面
|
@PostMapping("/domaincatalog-delete")
|
@ResponseBody
|
fun domaincatalogDelete(id: String): Int {
|
val i = domaincatalogService.delete(id)
|
return i
|
}
|
|
|
//值域值页面
|
@GetMapping("/domainitem-list")
|
fun domainitemList(model: Model): String {
|
//获取全部值域类型
|
// val domaincatalogVoList = domaincatalogService.findAll()
|
//根据值域类型获取值域值
|
// domaincatalogVoList.forEach {
|
// val domainitemVo = domainitemService.findByLogID(it.guid.toString())
|
// //赋值
|
// it.domainitemList = domainitemVo
|
// }
|
val list = domainitemService.findAll()
|
model.addAttribute("domainitems", list)
|
return "domainitem-list"
|
}
|
|
//值域表新增页面
|
@GetMapping("/domainitem-add")
|
fun domainitemAdd(id: String, model: Model): String {
|
var domainitem = DomainitemVo()
|
if ("" != id.trim()) {
|
domainitem = domainitemService.findOne(id)
|
}
|
//获取全部值域类型
|
val domaincatalogVoList = domaincatalogService.findAll()
|
model.addAttribute("domainitem", domainitem)
|
model.addAttribute("domaincatalogVoList", domaincatalogVoList)
|
return "domainitem-add"
|
}
|
|
//值域值新增请求处理
|
@PostMapping("/domainitem-add")
|
fun domainitemAddDo(domainitem: Domainitem): String {
|
//如果guid不为空,那就更新
|
if (!StringUtils.isEmpty(domainitem.guid)) {
|
domainitemService.update(domainitem)
|
} else {
|
//如果guid为空
|
//根据新增值域类型名称查询
|
val isno = domainitemService.findOneByName(domainitem.text!!)
|
//如果该值域类型不存在,则新增
|
if (isno.guid == null) {
|
domainitem.guid = UUIDGenerator.generate16ShortUUID()
|
domainitemService.save(domainitem)
|
}
|
//值域类型存在不进行任何处理
|
}
|
//都跳转到新增页面
|
return "success"
|
}
|
|
|
}
|
