csamsserver/src/main/kotlin/com/gyf/csams/Dao.kt

package com.gyf.csams


import com.gyf.csams.JoinAssociations.defaultExpression
import org.jetbrains.exposed.dao.IntEntity
import org.jetbrains.exposed.dao.IntEntityClass
import org.jetbrains.exposed.dao.id.EntityID
import org.jetbrains.exposed.dao.id.IntIdTable
import org.jetbrains.exposed.sql.Column
import org.jetbrains.exposed.sql.`java-time`.CurrentDateTime
import org.jetbrains.exposed.sql.`java-time`.CurrentTimestamp
import org.jetbrains.exposed.sql.`java-time`.datetime
import java.time.LocalDateTime

open class Person:IntIdTable(){

    @TableComment("姓名")
    val name:Column<String> = varchar(name="name",length = 10)

    @TableComment("密码")
    val password:Column<String> = varchar(name="password",length = 32)

    @TableComment("个人简介")
    val desc:Column<String> = varchar(name="desc",length = 20).default("")

    @TableComment("头像")
    val imgId:Column<EntityID<Int>?> = reference("img_id", ImageFiles).nullable()
}

@TableComment("用户")
object Users: Person(){
    @TableComment("学号")
    val studentId:Column<String> = varchar(name="student_id",length = 8).uniqueIndex()
}

class User(id:EntityID<Int>):IntEntity(id){
    companion object : IntEntityClass<User>(Users)
    var studentId by Users.studentId
    var name by Users.name
    var password by Users.password
    var desc by Users.desc
    var headImg by ImageFile optionalReferencedOn Users.imgId
}


@TableComment("后台管理员")
object Managers:Person(){
    @TableComment("帐号")
    val account:Column<String> = varchar(name="account",length=10)

    @TableComment("职务")
    val duty:Column<String> = varchar(name="duty",length = 32)
}

class Manager(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<Manager>(Managers)
    var account by Managers.account
    var password by Managers.password
    var duty by Managers.duty
    var desc by Managers.desc
    var name by Managers.name
    val headImg by ImageFile optionalReferencedOn Managers.imgId
}



open class BaseTokens:IntIdTable(){
    @TableComment("令牌")
    val token:Column<String> = varchar(name="token",length = 32)

    @TableComment("授权ip地址")
    val ip:Column<String> = varchar(name="ip",length = 32)

    @TableComment("令牌创建时间")
    val createTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentTimestamp())

    @TableComment("授权设备")
    val device:Column<String> = varchar(name="device",length = 256)
}

@TableComment("用户授权令牌")
object UserTokens: BaseTokens(){
    @TableComment("授权用户")
    val userId:Column<EntityID<Int>> = reference("user_id",Users)
}

class UserToken(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<UserToken>(UserTokens)
    var user by User referencedOn UserTokens.userId
    var token by UserTokens.token
    var ip by UserTokens.ip
    var createTime by UserTokens.createTime
    var device by UserTokens.device
}

@TableComment("管理员授权令牌")
object ManagerTokens:BaseTokens(){
    @TableComment("授权管理员")
    val managerId:Column<EntityID<Int>> = reference("manager_id",Managers)
}

class ManagerToken(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<ManagerToken>(ManagerTokens)
    var manager by Manager referencedOn ManagerTokens.managerId
    var token by ManagerTokens.token
    var ip by ManagerTokens.ip
    var createTime by ManagerTokens.createTime
    var device by ManagerTokens.device
}

@TableComment("留言")
object LeaveMessages:IntIdTable(){
    @TableComment("留言用户")
    val userId:Column<EntityID<Int>> = reference("user_id",Users)

    @TableComment("留言内容")
    val message:Column<String> = varchar(name = "message",length = 20)

    @TableComment("留言创建时间")
    val createTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentDateTime())
}

class LeaveMessage(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<LeaveMessage>(LeaveMessages)
    var user by User referencedOn LeaveMessages.userId
    var message by LeaveMessages.message
    var createTime by LeaveMessages.createTime
}

@TableComment("图片文件信息")
object ImageFiles:IntIdTable(){
    @TableComment("上传用户")
    val userId:Column<String> = varchar(name = "user_id",length = 10)

    @TableComment("文件相对路径")
    val filepath:Column<String> = varchar(name="filepath",length = 50)

    @TableComment("文件hash")
    val md5:Column<String> = varchar(name="md5",length = 32)

    @TableComment("文件创建时间")
    val createTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentDateTime())
}

class ImageFile(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<ImageFile>(ImageFiles)
    var userId by ImageFiles.userId
    var filepath by ImageFiles.filepath
    var md5 by ImageFiles.md5
    var createTime by ImageFiles.createTime
}

abstract class  AbstractAudits:IntIdTable(){
    abstract val auditId:Column<EntityID<Int>>
}

@TableComment("社团信息")
object Associations:AbstractAudits(){
    @TableComment("社团名称")
    val name:Column<String> = varchar(name = "name", length = 10)

    @TableComment("社团介绍")
    val desc:Column<String> = varchar(name = "desc", length = 30)

    @TableComment("社团logo")
    val logo:Column<EntityID<Int>> = reference("logo", ImageFiles)

    @TableComment("审核信息")
    override val auditId:Column<EntityID<Int>> = reference("audit_id",AuditLeggings)

    @TableComment("社团级别")
    val level:Column<String?> = varchar(name="level",length = 1).nullable()

    @TableComment("所属院系")
    val faculty:Column<String> = varchar(name="faculty",length = 32)
}

abstract class AbstractAudit(id:EntityID<Int>):IntEntity(id){
    abstract var audit: AuditLogging

    abstract fun notificationName():String
}

class Association(id:EntityID<Int>):AbstractAudit(id){
    companion object:IntEntityClass<Association>(Associations)
    var name by Associations.name
    var desc by Associations.desc
    var logo by ImageFile referencedOn Associations.logo
    var level by Associations.level
    var faculty by Associations.faculty
    override var audit by AuditLogging referencedOn Associations.auditId

    override fun notificationName(): String {
        return name
    }
}

@TableComment("社团成员信息")
object AssociationMembers:IntIdTable(){
    @TableComment("社团成员id")
    val userId:Column<EntityID<Int>> = reference("user_id",Users)

    @TableComment("社团Id")
    val associationId:Column<EntityID<Int>> = reference("association_id",Associations)

    @TableComment("是否团长")
    val isHead:Column<Boolean> = bool("is_head")
}

class AssociationMember(id:EntityID<Int>):IntEntity(id) {
    companion object : IntEntityClass<AssociationMember>(AssociationMembers)
    var user by User referencedOn AssociationMembers.userId
    var association by Association referencedOn AssociationMembers.associationId
    var isHead by AssociationMembers.isHead
}


@TableComment("审核记录")
object AuditLeggings:IntIdTable(){
    @TableComment("申请人")
    val userId: Column<EntityID<Int>>  = reference("user_id",Users)

    @TableComment("申请时间")
    val applyTime:Column<LocalDateTime> = datetime("apply_time").defaultExpression(CurrentDateTime())

    @TableComment("负责人")
    val managerId: Column<EntityID<Int>?> = reference("manager_id",Managers).nullable()

    @TableComment("受理时间")
    val acceptTime:Column<LocalDateTime?> = datetime("accept_time").nullable()

    @TableComment("审核理由")
    val cause:Column<String?> = varchar("cause",length = 30).nullable()

    @TableComment("审核结果")
    val result:Column<Boolean?> = bool("result").nullable()

    @TableComment("审核时间")
    val auditTime:Column<LocalDateTime?> = datetime("audit_time").nullable()

    @TableComment("复审记录")
    val nextAudit:Column<EntityID<Int>?> = reference("next_audit",AuditLeggings).nullable()
}

class AuditLogging(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<AuditLogging>(AuditLeggings)
    var user by User referencedOn AuditLeggings.userId
    var applyTime by AuditLeggings.applyTime
    var manager by Manager optionalReferencedOn  AuditLeggings.managerId
    var acceptTime by AuditLeggings.acceptTime
    var cause by AuditLeggings.cause
    var result by AuditLeggings.result
    var auditTime by AuditLeggings.auditTime
    var nextAudit by AuditLogging optionalReferencedOn AuditLeggings.nextAudit
}

@TableComment("通知记录")
object Notifications:IntIdTable(){
    @TableComment("通知标题")
    val title:Column<String> = varchar(name="title",length = 10)

    @TableComment("通知内容")
    val content:Column<String> = varchar(name="content",length = 256)

    @TableComment("接收者")
    val receiverId:Column<Int> = integer(name="receiver_id")

    @TableComment("接收客户端")
    val receiverClient:Column<String> = varchar(name="receiver_client",length = 10)

    @TableComment("阅读状态")
    val read:Column<Boolean> = bool("read").default(false)

    @TableComment("拉取状态")
    val pull:Column<Boolean> = bool("pull").default(false)

    @TableComment("通知创建时间")
    val createTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentDateTime())
}

class Notification(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<Notification>(Notifications)
    var title by Notifications.title
    var content by Notifications.content
    var receiverId by Notifications.receiverId
    var receiverClient by Notifications.receiverClient
    var read by Notifications.read
    var pull by Notifications.pull
    var createTime by Notifications.createTime
}

@TableComment("社团活动")
object Activities:AbstractAudits(){
    @TableComment("活动名称")
    val activityName:Column<String> = varchar(name="activity_name",length = 10)

    @TableComment("活动时间")
    val activityTime:Column<LocalDateTime> = datetime("activity_time")

    @TableComment("活动地点")
    val activityAddress:Column<String> = varchar(name="activity_address",length = 30)

    @TableComment("活动介绍")
    val activityDesc:Column<String> = varchar(name="activity_desc",length = 30)

    @TableComment("活动人数")
    val activitySize:Column<Int> = integer("activity_size")

    @TableComment("活动社团")
    val associationId:Column<EntityID<Int>> = reference("association_id",Associations)

    @TableComment("审核信息")
    override val auditId:Column<EntityID<Int>> = reference("audit_id",AuditLeggings)
}

class Activity(id:EntityID<Int>):AbstractAudit(id){
    companion object:IntEntityClass<Activity>(Activities)
    var activityName by Activities.activityName
    var activityTime by Activities.activityTime
    var activityAddress by Activities.activityAddress
    var activityDesc  by Activities.activityDesc
    var activitySize by Activities.activitySize
    var association by Association referencedOn Activities.associationId

    override var audit by AuditLogging referencedOn Activities.auditId

    override fun notificationName(): String {
        return activityName
    }
}

@TableComment("相册")
object PhotoAlbums:IntIdTable(){
    @TableComment("所属活动")
    val activityId:Column<EntityID<Int>> = reference("activity_id",Activities)

    @TableComment("照片")
    val photoId:Column<EntityID<Int>> = reference("photo_id",ImageFiles)

    @TableComment("照片名")
    val name:Column<String> = varchar("name",length = 10)
}

class PhotoAlbum(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<PhotoAlbum>(PhotoAlbums)
    var activity by Activity referencedOn PhotoAlbums.activityId
    var photo by ImageFile referencedOn PhotoAlbums.photoId
    var name by PhotoAlbums.name
}

@TableComment("活动评论")
object ActivityComments:IntIdTable(){
    @TableComment("评论内容")
    val content:Column<String> = varchar("content",length = 80)

    @TableComment("评论时间")
    val createTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentDateTime())

    @TableComment("评论用户")
    val userId:Column<EntityID<Int>> = reference("user_id",Users)

    @TableComment("评论活动")
    val activityId:Column<EntityID<Int>> = reference("activity_id",Activities)
}

class ActivityComment(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<ActivityComment>(ActivityComments)
    var content by ActivityComments.content
    var createTime by ActivityComments.createTime
    var user by User referencedOn  ActivityComments.userId
    var activity by Activity referencedOn ActivityComments.activityId
}

@TableComment("社团重命名记录")
object Renames:AbstractAudits(){
    @TableComment("新名称")
    val newName:Column<String> = varchar("new_name",length = 10)

    @TableComment("换名理由")
    val cause:Column<String> = varchar("cause",length = 30)

    @TableComment("重命名社团")
    val associationId:Column<EntityID<Int>> = reference("association_id",Associations)

    @TableComment("审核信息")
    override val auditId:Column<EntityID<Int>> = reference("audit_id",AuditLeggings)
}

class Rename(id:EntityID<Int>):AbstractAudit(id){
    companion object:IntEntityClass<Rename>(Renames)
    var newName by Renames.newName
    var cause by Renames.cause
    var association by Association referencedOn  Renames.associationId
    override var audit by AuditLogging referencedOn Renames.auditId

    override fun notificationName(): String {
        return "${association.name} -> $newName"
    }
}

@TableComment("题库")
object Questions:IntIdTable(){
    @TableComment("问题")
    val question:Column<String> = varchar("question",30)

    @TableComment("选项A")
    val optionsA:Column<String> = varchar("optionsA",15)

    @TableComment("选项B")
    val optionsB:Column<String> = varchar("optionsB",15)

    @TableComment("选项C")
    val optionsC:Column<String> = varchar("optionsC",15)

    @TableComment("选项D")
    val optionsD:Column<String> = varchar("optionsD",15)

    @TableComment("答案")
    val answer:Column<Int> = integer("answer")

    @TableComment("所属社团")
    val associationId:Column<EntityID<Int>> = reference("association_id",Associations)
}

class Question(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<Question>(Questions)
    var question by Questions.question
    var optionsA by Questions.optionsA
    var optionsB by Questions.optionsB
    var optionsC by Questions.optionsC
    var optionsD by Questions.optionsD
    var answer by Questions.answer
    var association by Association referencedOn Questions.associationId
}

@TableComment("试题")
object Answers:IntIdTable(){
    @TableComment("问题")
    val questionId:Column<EntityID<Int>> = reference("question_id",Questions)

    @TableComment("答案")
    val answer:Column<Int> = integer("answer")

    @TableComment("入团申请记录")
    val joinId:Column<EntityID<Int>> = reference("join_id",JoinAssociations)
}

class Answer(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<Answer>(Answers)
    var question by Question referencedOn Answers.questionId
    var answer by Answers.answer
    var join by JoinAssociation referencedOn Answers.joinId
}

@TableComment("入团申请记录")
object JoinAssociations:IntIdTable(){
    @TableComment("申请人")
    val userId:Column<EntityID<Int>> = reference("user_id",Users)

    @TableComment("申请社团")
    val associationId:Column<EntityID<Int>> = reference("association_id",Associations)

    @TableComment("申请时间")
    val applyTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentDateTime())

    @TableComment("审核时间")
    val auditTime:Column<LocalDateTime?> = datetime("audit_time").nullable()

    @TableComment("申请结果")
    val result:Column<Boolean?>  = bool("result").nullable()
}

class JoinAssociation(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<JoinAssociation>(JoinAssociations)
    var user by User referencedOn  JoinAssociations.userId
    var association by Association referencedOn JoinAssociations.associationId
    var result by JoinAssociations.result
    var applyTime by JoinAssociations.applyTime
    var auditTime by JoinAssociations.auditTime
}

@TableComment("用户倾向")
object Tendencies:IntIdTable(){
    @TableComment("点赞用户")
    val userId:Column<EntityID<Int>> = reference("user_id",Users)

    @TableComment("点赞活动")
    val activityId:Column<EntityID<Int>> = reference("activity_id",Activities)

    @TableComment("点赞时间")
    val createTime:Column<LocalDateTime> = datetime("create_time").defaultExpression(CurrentDateTime())

    @TableComment("倾向类型")
    val type:Column<Int> = integer("type")
}

class Tendency(id:EntityID<Int>):IntEntity(id){
    companion object:IntEntityClass<Tendency>(Tendencies)
    var user by User referencedOn Tendencies.userId
    var activity by Activity referencedOn Tendencies.activityId
    val createTime by Tendencies.createTime
    var type by Tendencies.type
}