infrastructure

mdb:
  databases:
    - item:
        password: password
        user: user
        url: jdbc:mysql://server:13306/databaseName
        type: com.mysql.cj.jdbc.MysqlDataSource
        driver: com.mysql.cj.jdbc.Driver
        max: 100
        idle: 100
      mapper: ''
      name: partner
  desc: partner

@Slf4j
@Configuration
@EnableTransactionManagement
@MapperScan(basePackages = "com.yp.apps.partner.domain.mapper", sqlSessionTemplateRef  = "partnerSqlSessionTemplate")
public class PartnerDataSource {
}

security:
  secret: juxj.net
  expired: 10

@Aggregate
class PartnerAggregate constructor() : BaseAggregate() {

    val log: Logger = LoggerFactory.getLogger(PartnerAggregate::class.java)

    lateinit var code: String
    lateinit var name: String

    @AggregateMember
    var customers: MutableSet<String> = mutableSetOf()

    @AggregateMember
    var vendors: MutableSet<String> = mutableSetOf()


    @CommandHandler
    constructor(cmd: CreatePartnerCommand) : this() {
        val e = CreatePartnerEvent(cmd.code, cmd.name, cmd.owner, cmd.type)
        e.id = cmd.id
        AggregateLifecycle.apply(e)
    }


    @EventHandler
    fun on(e: CreatePartnerEvent) {
        log.debug("....")
        this.id = e.id
        this.code = e.code
        this.name = e.name
        when (e.type) {
            EnumPartnerType.CUSTOMER -> {
                if (customers.contains(e.owner)) throw PartnerException(EnumErrorMessage.CUSTOMER_EXISTS)
                customers.add(e.owner)
            }
            EnumPartnerType.VENDOR -> {
                if (customers.contains(e.owner)) throw PartnerException(EnumErrorMessage.VENDOR_EXISTS)
                vendors.add(e.owner)
            }
            else -> {
                throw PartnerException(EnumErrorMessage.UNKNOWN_PARTNER_TYPE)
            }
        }
    }

}


abstract class AbstractAxonHandler : AbstractHandler() {
    /**
     * 查询聚合实体
     * @param repository 聚合仓库
     * @param id 聚合id
     * @param e 空值是否异常, 默认(true),空值抛异常
     */
    @Throws(AggregateNotFoundException::class)
    protected inline fun <reified T : AxonAggregateRoot> getAxonAggregate(
        repository: EventSourcingRepository<T>,
        id: String,
        e: Boolean = true
    ): T {
        val aggregate = repository.load(id).wrappedAggregate.aggregateRoot
        if (null == aggregate && e) {
            logger.warn("聚合未找到: {}, type:{}", id, T::class.simpleName)
            throw AggregateNotFoundException("Aggregate Not found", id)
        }
        return aggregate
    }
}

/**
 * 命令责职抽象类
 */
abstract class AbstractPartnerCommand(open val owner: String) : BaseAxonCommand() {
    constructor(id: String, owner: String) : this(owner) {
        this.id = id
    }
}

/**
 * 创建命令
 */
data class CreatePartnerCommand(
     val code: String,  val name: String, override val owner: String, val type: EnumPartnerType
) : AbstractPartnerCommand(owner)


/**
 * 更改状态
 */
data class ChangePartnerStatusCommand(
     val partnerId: String, override val owner: String,  val status: EnumAvailable, val type: EnumPartnerType
) : AbstractPartnerCommand(partnerId, owner)

/**
 * Partner事件抽象类
 */
abstract class AbstractPartnerEvent(open val owner: String) : BaseAxonEvent() {
    constructor(id: String, owner: String) : this(owner) {
        this.id = id
    }
}

/**
 * 创建Partner
 */
data class CreatePartnerEvent(
    val code: String, val name: String, override val owner: String, val type: EnumPartnerType
) : AbstractPartnerEvent(owner)


/**
 * 更改Partner状态
 */
data class ChangePartnerStatusEvent(
    val partnerId: String, override val owner: String, val status: EnumAvailable, val type: EnumPartnerType
) : AbstractPartnerEvent(partnerId, owner)

/**
 * 模糊查询
 */
data class QueryPartnerByName(val name: String, val type: EnumPartnerType) : BaseAxonQuery()

    @LazyAutowired
    lateinit var partnerMapper: PartnerMapper

    @LazyAutowired
    lateinit var partnerTypeMapper: PartnerTypeMapper

    @LazyAutowired
    lateinit var partnerShipMapper: PartnerShipMapper

    /**
     * 处理创建Partner创建事件， 如写数据， 或进行其他发布新的事件， 供后续处理
     */
    @EventHandler
    fun on(e: CreatePartnerEvent) {
        log.debug("event  handler.")
    }

    /**
     * 事件库
     */
    @LazyAutowired
    lateinit var repository : EventSourcingRepository<PartnerAggregate>;
    
    /**
     * Mapper
     */
    @LazyAutowired
    lateinit var partnerMapper: PartnerMapper

    @LazyAutowired
    lateinit var partnerTypeMapper: PartnerTypeMapper

    @LazyAutowired
    lateinit var partnerShipMapper: PartnerShipMapper
    /**
     * 可以通过Mybatis+到数据库查(MySql)， 也可以通过EventSourcing到事件库(Mongodb)查询
     */
    @QueryHandler
    fun on(q: QueryPartnerByName): List<PartnerVo>? {
        return emptyList()
    }