package cn.flightfeather.supervision.lightshare.service.Impl
|
|
import cn.flightfeather.supervision.common.wx.TemplateManager
|
import cn.flightfeather.supervision.domain.entity.*
|
import cn.flightfeather.supervision.domain.enumeration.DistrictType
|
import cn.flightfeather.supervision.domain.enumeration.UserType
|
import cn.flightfeather.supervision.lightshare.repository.MeetingParticipantRepository
|
import cn.flightfeather.supervision.lightshare.service.NotificationService
|
import cn.flightfeather.supervision.lightshare.vo.NoticeReadStateVo
|
import cn.flightfeather.supervision.lightshare.vo.NotificationVo
|
import cn.flightfeather.supervision.common.push.PushService
|
import cn.flightfeather.supervision.domain.enumeration.ParticipantType
|
import cn.flightfeather.supervision.domain.enumeration.SceneType
|
import cn.flightfeather.supervision.domain.mapper.*
|
import cn.flightfeather.supervision.infrastructure.utils.UUIDGenerator
|
import cn.flightfeather.supervision.lightshare.vo.BaseResponse
|
import cn.flightfeather.supervision.lightshare.vo.DataHead
|
import com.flightfeather.taizhang.model.enumeration.NotificationType
|
import com.flightfeather.taizhang.model.enumeration.WorkSubType
|
import com.github.pagehelper.PageHelper
|
import org.springframework.stereotype.Service
|
import tk.mybatis.mapper.entity.Example
|
import java.lang.StringBuilder
|
import java.util.*
|
import java.util.concurrent.Executors
|
import javax.servlet.http.HttpServletResponse
|
|
@Service
|
class NotificationServiceImpl(
|
val notificationMapper: NotificationMapper,
|
val noticeMapper: NoticeMapper,
|
val noticeReadStateMapper: NoticeReadStateMapper,
|
val noticeTemplateMapper: NoticeTemplateMapper,
|
val userinfoMapper: UserinfoMapper,
|
val baseInfoMapper: BaseInfoMapper,
|
val meetingParticipantRepository: MeetingParticipantRepository,
|
val templateManager: TemplateManager,
|
) : NotificationService {
|
|
override fun getAllNotices(
|
userId: String,
|
noticeConfig: NoticeConfig,
|
page: Int,
|
perPage: Int,
|
): BaseResponse<List<Notice>> {
|
// val userInfo = userinfoMapper.selectByPrimaryKey(userId)
|
val p = PageHelper.startPage<Notice>(page, perPage)
|
val nList = noticeMapper.selectByExample(Example(Notice::class.java).apply {
|
createCriteria().apply {
|
if (noticeConfig.ecNoticetype != null && noticeConfig.ecNoticetype != 0) {
|
andEqualTo("ecNoticetype", noticeConfig.ecNoticetype)
|
}
|
if (noticeConfig.ecNoticesubtype != null && noticeConfig.ecNoticesubtype != 0) {
|
andEqualTo("ecNoticesubtype", noticeConfig.ecNoticesubtype)
|
}
|
}
|
orderBy("ecUpdatedate").desc()
|
})
|
return BaseResponse(true, head = DataHead(p.pageNum, p.pages, p.total), data = nList)
|
}
|
|
override fun getNotificationUnRead(
|
userId: String,
|
page: Int,
|
per_page: Int,
|
response: HttpServletResponse,
|
): List<NotificationVo> {
|
val userInfo = userinfoMapper.selectByPrimaryKey(userId) ?: return emptyList()
|
val baseInfo = baseInfoMapper.selectByPrimaryKey(userId)
|
val userTypeId = userInfo.usertypeid
|
val district = userInfo.extension1
|
var districtCode = DistrictType.getCode(district) ?: baseInfo?.biDistrictCode
|
var sceneTypeId = userInfo.extension2
|
|
when (userTypeId?.toInt()) {
|
UserType.Admin.value,
|
UserType.Insider.value,
|
-> {
|
districtCode = null
|
sceneTypeId = null
|
}
|
UserType.Gov.value -> {
|
sceneTypeId = null
|
}
|
UserType.Enterprise.value -> {
|
//do nothing
|
}
|
}
|
|
val myPage = PageHelper.startPage<Notice>(page, per_page)
|
|
val noticeIdList = mutableListOf<String?>()
|
val resultList = noticeMapper.getUnReadNotification(userId, districtCode, sceneTypeId, userTypeId).onEach { vo ->
|
noticeIdList.add(vo.id)
|
}
|
if (noticeIdList.isEmpty()) {
|
return resultList
|
}
|
val readStateList = noticeReadStateMapper.selectByExample(Example(NoticeReadState::class.java).apply {
|
createCriteria().andEqualTo("nrUserid", userId)
|
.andIn("ecGuid", noticeIdList)
|
})
|
|
resultList.forEach {
|
for (i in readStateList.indices) {
|
val r = readStateList[i]
|
if (it.id == r.ecGuid) {
|
it.hasRead = r.nrReadstate
|
it.hasSigned = r.nrSignstate
|
break
|
}
|
}
|
}
|
|
response.setIntHeader("totalPage", myPage.pages)
|
response.setIntHeader("currentPage", myPage.pageNum)
|
|
return resultList
|
}
|
|
override fun updateReadState(userId: String, readStates: List<NoticeReadStateVo>) {
|
readStates.forEach {
|
val noticeReadState = NoticeReadState().apply {
|
nrUserid = userId
|
ecGuid = it.noticeId
|
nrReadstate = it.hasRead
|
nrSignstate = it.hasSigned
|
val example = Example(NoticeReadState::class.java)
|
example.createCriteria().andEqualTo("nrUserid", nrUserid)
|
.andEqualTo("ecGuid", ecGuid)
|
val result = noticeReadStateMapper.selectByExample(example)
|
if (result.isEmpty()) {
|
noticeReadStateMapper.insert(this)
|
} else {
|
nrId = result[0].nrId
|
noticeReadStateMapper.updateByPrimaryKey(this)
|
}
|
}
|
}
|
}
|
|
override fun getNotificationText(notificationId: String): String {
|
val notification = notificationMapper.selectByPrimaryKey(notificationId)
|
return notification.ntContent
|
}
|
|
// override fun getUnReadNoticeNum(userId: String): Int {
|
// val example = Example(NoticeReadState::class.java)
|
// example.createCriteria()
|
// .andEqualTo("nrUserid", userId)
|
// example.and(example.createCriteria()
|
// .andEqualTo("nrReadstate", true)
|
// .andEqualTo("nrSignstate", true)
|
// )
|
//
|
// val readNum = noticeReadStateMapper.selectCountByExample(example)
|
// val userInfo = userinfoMapper.selectByPrimaryKey(userId)
|
// val totalNum = noticeMapper.selectByUser(userInfo?.extension2 ?: "-1",
|
// userId, 1, 1000).size
|
//// noticeMapper.selectCountByExample(Example(Notice::class.java))
|
//
|
// return totalNum - readNum
|
// }
|
|
override fun getUnReadNoticeNum(userId: String): Int {
|
val userInfo = userinfoMapper.selectByPrimaryKey(userId) ?: return 0
|
val baseInfo = baseInfoMapper.selectByPrimaryKey(userId)
|
val userTypeId = userInfo.usertypeid
|
val district = userInfo.extension1
|
var districtCode = DistrictType.getCode(district) ?: baseInfo?.biDistrictCode
|
var sceneTypeId = userInfo.extension2
|
|
when (userTypeId?.toInt()) {
|
UserType.Admin.value,
|
UserType.Insider.value,
|
-> {
|
districtCode = null
|
sceneTypeId = null
|
}
|
UserType.Gov.value -> {
|
sceneTypeId = null
|
}
|
UserType.Enterprise.value -> {
|
//do nothing
|
}
|
}
|
|
val noticeIdList = mutableListOf<String?>()
|
val resultList = noticeMapper.getUnReadNotification(userId, districtCode, sceneTypeId, userTypeId).also {
|
it.forEach { vo ->
|
noticeIdList.add(vo.id)
|
}
|
}
|
if (noticeIdList.isEmpty()) {
|
return 0
|
}
|
val readStateList = noticeReadStateMapper.selectByExample(Example(NoticeReadState::class.java).apply {
|
createCriteria().andEqualTo("nrUserid", userId)
|
})
|
|
var totalCount = resultList.size
|
readStateList.forEach {
|
if (noticeIdList.contains(it.ecGuid) && it.nrSignstate && it.nrReadstate) {
|
totalCount--
|
}
|
if (totalCount < 0) {
|
totalCount = 0
|
}
|
}
|
|
return totalCount
|
}
|
|
override fun pushMeetingReleaseNotification(
|
meetingVo: MeetingInfo,
|
roomVo: VMRoom?,
|
userId: String,
|
title: String,
|
body: String,
|
) {
|
val accountList = mutableListOf<String>()
|
meetingParticipantRepository.getParticipantByType(meetingVo.miGuid
|
?: "", roomVo?.vmrGuid, ParticipantType.All.value).forEach {
|
if (it.mpParticipantid != userId) {
|
accountList.add(it.mpParticipantid)
|
}
|
}
|
// Executors.newSingleThreadExecutor().execute {
|
// PushService().run {
|
// pushByAccount(accountList)
|
// push(meetingVo.miTitle ?: title, body)
|
// }
|
// }
|
val receiverId = StringBuilder()
|
accountList.forEach {
|
receiverId.append(it)
|
receiverId.append(";")
|
}
|
|
val user = userinfoMapper.selectByPrimaryKey(userId)
|
|
val notificationVo = NotificationVo(
|
UUIDGenerator.generate16ShortUUID(),
|
user?.guid,
|
user?.realname,
|
user?.headIconUrl,
|
NotificationType.Work.value.toString(),
|
NotificationType.Work.des,
|
WorkSubType.Meeting.value.toString(),
|
WorkSubType.Meeting.des,
|
meetingVo.miTitle ?: title,
|
body,
|
receiverType = "-1",
|
receiverId = receiverId.toString(),
|
district = "-1"
|
)
|
|
releaseNotice(userId, notificationVo)
|
}
|
|
override fun releaseNotice(userId: String, noticeVo: NotificationVo): Boolean {
|
val notice = Notice().apply {
|
noticeVo.let {
|
ecGuid = if (it.id == null) UUIDGenerator.generate16ShortUUID() else it.id
|
ecNoticetype = it.typeId?.toInt()
|
ecNoticetypename = it.typeName
|
ecNoticesubtype = it.subTypeId?.toInt()
|
ecNoticesubtypename = it.subTypeName
|
ecNoticetitle = it.title
|
ecNoticecontent = it.content
|
ecIsinuse = true
|
ecCreatedate = Date()
|
ecCreatorid = it.authorId
|
ecCreator = it.authorName
|
ecUpdatedate = Date()
|
ecModifierid = it.authorId
|
ecModifier = it.authorName
|
ecReceivertype = it.receiverType
|
ecReceiverid = it.receiverId
|
ecPicurl = it.picUrl
|
ecBodyurl = it.bodyUrl
|
ecNeedsign = it.needSigned
|
ecExtension1 = it.district
|
}
|
}
|
// Executors.newSingleThreadExecutor().execute {
|
// PushService().run {
|
// if (noticeVo.receiverId?.isNotBlank() == true) {
|
// val accountList = noticeVo.receiverId!!.split(";")
|
// pushByAccount(accountList)
|
// } else {
|
// val accountList = mutableListOf<String>()
|
// val districts = mutableListOf<String>()
|
// val sceneTypes = mutableListOf<String>()
|
// noticeVo.district?.split(";")?.forEach {
|
// if (it.isNotBlank()) {
|
// districts.add(it)
|
// }
|
// }
|
// noticeVo.receiverType.split(";")?.forEach {
|
// if (it.isNotBlank()) {
|
// sceneTypes.add(it)
|
// }
|
// }
|
// val districtCodeList = mutableListOf<String>()
|
// districts.forEach {
|
// DistrictType.getDes(it)?.let { d-> districtCodeList.add(d)}
|
// }
|
// userinfoMapper.selectByExample(Example(Userinfo::class.java).apply {
|
// createCriteria()
|
// .apply {
|
// if (districts.isNotEmpty()) {
|
// andIn("extension1", districtCodeList)
|
// }
|
// if (noticeVo.receiverType != SceneType.NoType.value.toString()) {
|
// andIn("extension2", sceneTypes)
|
// }
|
// }
|
// }).forEach {
|
// accountList.add(it.guid ?: "")
|
// }
|
// pushByAccount(accountList)
|
// }
|
// push(noticeVo.title?:"新通知", noticeVo.content?:"新通知")
|
// }
|
// }
|
return noticeMapper.insert(notice) == 1
|
}
|
|
override fun releaseNotice2(userId: String, noticeVo: NotificationVo): Notice {
|
val notice = Notice().apply {
|
noticeVo.let {
|
ecGuid = if (it.id == null) UUIDGenerator.generate16ShortUUID() else it.id
|
ecNoticetype = it.typeId?.toInt()
|
ecNoticetypename = NotificationType.getByValue(ecNoticetype)
|
ecNoticesubtype = it.subTypeId?.toInt()
|
ecNoticesubtypename = WorkSubType.getByValue(ecNoticetype, ecNoticesubtype)
|
ecNoticetitle = it.title
|
ecNoticecontent = it.content
|
ecIsinuse = true
|
ecCreatedate = Date()
|
ecCreatorid = it.authorId
|
ecCreator = it.authorName
|
ecUpdatedate = Date()
|
ecModifierid = it.authorId
|
ecModifier = it.authorName
|
ecReceivertype = if (it.receiverType != "-1") it.receiverType + ";" else "-1"
|
ecReceiverid = it.receiverId
|
ecPicurl = it.picUrl
|
ecBodyurl = it.bodyUrl
|
ecNeedsign = it.needSigned
|
ecExtension1 = if (it.district != "-1") it.district + ";" else "-1"
|
}
|
}
|
noticeMapper.insert(notice)
|
return notice
|
}
|
|
override fun pushMsgWx(templateId: Int): String {
|
val res = templateManager.sendMsg(templateId,
|
"otZkc5VRlwauEMPqMluQYdVa4zuE",
|
listOf("台账上传", "2022年10月10日", "3", "请重点关注现场自寻查部分"))
|
return if (res) "success" else "fail"
|
}
|
|
override fun getTemplate(typeId: Int, subTypeId: Int): BaseResponse<List<NoticeTemplate?>> {
|
val res = noticeTemplateMapper.selectByExample(Example(NoticeTemplate::class.java).apply {
|
createCriteria().andEqualTo("ntNoticeType", typeId).andEqualTo("ntNoticeSubType", subTypeId)
|
})
|
return BaseResponse(true, data = res)
|
}
|
}
|
