@Suppress("unused") // Referenced in application.conf
   @kotlin.jvm.JvmOverloads
   fun Application.module(testing: Boolean = false) 
   {
   
       clientLogConfigFunc = {
        level = LogLevel.BODY
        filter { it.url.host.contains("qyapi.weixin.qq.com") }//qyapi.weixin.qq.com
    }

    val app = this
    val mainModule = AppModule(
        listOf(module(createdAtStart = true){
            single<AbstractJwtHelper> { MyJwtHelper() } //MyJwtHelper
            single<Application> { app }
        }),null)

    installModule(mainModule)
     
    installModule(wxUserAppModule, dbName) //wxUser feedback等功能 需预置产品信息

   installModule(wxOaAppModule,dbName) //公众号基础接入模块

        //MsgNotifier url设置, 改成数据库中配置
   System.setProperty("xcshop.corpId", "wwfc2fead39b1e6xxx")
   System.setProperty("xcshop.agentId", "1000005")

        //企业微信应用配置模块: 配置数据需要在应用自己的库中，否则启动时加载了别的agent的配置
  installModule(wxWorkModule, dbName) 

    //暂寄宿于此
    installModule(xcShopModule, "rws_xc_db", DbType.SQL, "rws_xc","123456")

    //defaultInstall(enableWebSocket= true, logHeaders = listOf("X-Auth-UserId"))//"X-Auth-ExternalUserId",
    defaultInstall(enableWebSocket= true)
   
   }

val xcShopModule = AppModule(
    listOf(
        module(createdAtStart = true){
            single { OnStartDailyCommentJob(get()) }
        },
        module {
            single { LiGoodsService(get()) }
            single { LiGoodsController() }

            single { CommentController()}
            single { CommentService(get()) }
            single { OrderService(get()) }
            single { OrderController() }
        }),
    "rws_xiucheng_db"
) {
    goodsApi()
    orderApi()
    commentApi()
}

//默认情况下enableJsonApi为true，使用的是LocalDateTimeAsLongSerializer and ObjectId64Serializer
val MySerializeJson = Json {
    apiJsonBuilder()
    serializersModule = SerializersModule {
        contextual(LocalDateTimeAsStringSerializer) //默认情况下enableJsonApi为true，使用的是LocalDateTimeAsLongSerializer and ObjectId64Serializer
    }
}

@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
    // java -jar -DwithSPA=../webapp/www/ build/libs/RuleComposer-1.0.0-all.jar
    // java -jar -DwithSPA=../webapp/www/ -DdbHost=127.0.0.1 -DdbPort=3306 -DdbName=ruleEngineDb -DdbUser=root -DdbPwd=123456 -DdbHost=127 build/libs/RuleComposer-1.0.0-all.jar
    // nohup java -jar -DwithSPA=../webapp/www/ -DdbHost=127.0.0.1 -DdbPort=3306 -DdbName=ruleEngineDb -DdbUser=root -DdbPwd=123456 -DdbHost=127 build/libs/RuleComposer-1.0.0-all.jar > log/err.txt 2>&1 &
    val dbHost = System.getProperty("dbHost") ?: "127.0.0.1"
    val dbPort = System.getProperty("dbPort")?.toInt() ?: 3306
    val dbName = System.getProperty("dbName") ?: "ruleEngineDb"
    val dbUser = System.getProperty("dbUser") ?: "root"
    val dbPwd = System.getProperty("dbPwd") ?: "123456"
    val withSPA = System.getProperty("withSPA")

    val app = this
    val mainModule = AppModule(
        listOf(module(createdAtStart = true){
            single<Application> { app }
        }),null)

    installModule(mainModule)

    
   //使用SQL数据库，非默认设置
    installModule(bizModule,dbName, DbType.SQL, dbUser, dbPwd, dbHost, dbPort)

    //非默认配置
    defaultInstall(enableJwt = false, false, enableWebSocket = false)

    //https://ktor.io/servers/features/content-negotiation/serialization-converter.html
    //https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/custom_serializers.md
    install(ContentNegotiation) {
        json(
            json = MySerializeJson,
            contentType = ContentType.Application.Json
        )
    }
    if(withSPA != null){
        log.info("======withSPA=$withSPA======")
        routing {
            singlePageApplication {
                react(withSPA)
            }
        }
    }else{
        log.info("======installCORS======")
        installCORS(false)
    }
    log.info("======dbHost=$dbHost======")
    log.info("======dbPort=$dbPort======")
    log.info("======dbName=$dbName======")
    log.info("======dbUser=$dbUser======")
    log.info("======dbPort=$dbPort======")
}

/**
 * 安装appModule，实际完成功能是
 * （1）将待注入的koin module添加到一个私有全局列表，便于defaultInstall中进行 install(Koin)
 * （2）将routing配置加入私有全局列表，便于后面执行，添加endpoint
 * （3）自动注入了DataSource（以数据库名称作为qualifier）
 * @param app 待安装的module
 * @param dbType DbType.NOSQL, DbType.SQL
 * @param userName 连接数据的用户名，mysql通常需要赋值
 * @param pwd 连接数据的密码，mysql通常需要赋值
 * @param dbName 数据库名称，不指定则使用AppModule中的默认名称
 * @param host 数据库host 默认127.0.0.1
 * @param port 数据库port 对于NOSQL MongoDB，默认27017， SQL之MySQL为3306
 * */
fun Application.installModule(
    app: AppModule,
    dbName: String? = null,
    dbType: DbType = DbType.NOSQL,
    userName: String? = null,
    pwd: String? = null,
    host: String = "127.0.0.1",
    port: Int = when(dbType){
        DbType.NOSQL -> 27017
        DbType.SQL -> 3306
    }
)

    install(Koin){ ... }
    install(AutoHeadResponse)
    install(ForwardedHeaders)
    install(XForwardedHeaders)
    install(PartialContent)
    install(Resources)
    install(CallLogging){
        ...
    }

/**
 * @param enableJwt 为false时只适合于route中无authentication时的情况
 * @param enableJsonApi 是否打开api接口json序列化
 * @param jsonBuilderAction 添加额外的自定义json配置，通常用于添加自己的json contextual
 * @param enableWebSocket 是否开启websocket
 * @param logHeaders 需要输出哪些请求头，用于调试
 * @param cache 自动注入 CaffeineCache，如不需要可使用VoidCache代替
 * */
@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.defaultInstall(
    enableJwt: Boolean = true,
    enableJsonApi: Boolean = true,
    jsonBuilderAction: (JsonBuilder.() -> Unit)? = null,
    enableWebSocket: Boolean = false,
    logHeaders: List<String>? = null, //"X-Auth-uId","X-Auth-UserId", "X-Auth-ExternalUserId", "X-Auth-oId", "X-Auth-unId","X-Auth-CorpId","Authorization"
    cache: ICache = CaffeineCache()
)

fun Application.installCORS(backOfNginx: Boolean)

if(withSPA != null){
        log.info("======withSPA=$withSPA======")
        routing {
            singlePageApplication {
                react(withSPA)
            }
        }
    }else{
        log.info("======installCORS======")
        installCORS(false)
    }

//openssl genrsa -out rsa_private.key 2048
open class MyJwtHelper: UserInfoJwtHelper("https://wxAddmin.rwsbillyang.github.com/",
    "-----BEGIN RSA PRIVATE KEY-----\n" +
        "......"  +
    "-----END RSA PRIVATE KEY-----\n"

)
{

    //private val accountController: AccountController by inject()

    //private val userService: UserService by inject()

    override fun isValidUser(uId: String, payload: Payload): Boolean{
        //只做格式合法性检查
        return try{
            uId.toObjectId()
            true
        }catch (e:Exception){
            log.warn("invalid ObjectId uId=$uId")
            false
        }


        //val user = userService.findById(uId)
        //return user != null && user.status != User.StatusDisabled
    }
}

 authenticate {
            // verify admin privileges
            intercept(ApplicationCallPipeline.Call) {
                //log.info("intercept admin save: ${call.request.uri}")
                when (jwtHelper.isAuthorized(call, listOf("admin", "user"))) { //需要admin 或 user角色才可访问
                    false -> {
                        call.respond(HttpStatusCode.Forbidden)
                        return@intercept finish()
                    }
                    else -> proceed()
                }
            }

            route("/admin") {
                get<ArticleListParams> {
                    if(it.outline == 1){
                        call.respondBox(DataBox.ok(controller.outlineList(it)))
                    }else{
                        call.respond(controller.list(it, call.uId, call.isFromAdmin()))
                    }
                }
             }              
}

fun Application.simpleTestableModule() {
    routing {
        get("/ok") {
            call.respondText("OK", contentType = ContentType.Text.Plain)
        }
    }
}

fun Application.testModule(module: AppModule) {
    val app = this
    installModule(AppModule(
        listOf(module(createdAtStart = true) {
            single<UserInfoJwtHelper> { TestJwtHelper() }
            single<AbstractJwtHelper> { DevJwtHelper() }
            single<Application> { app }
        }), null))
    installModule(module)
    defaultInstall(true)
}

   class WxConfigInstallation(application: Application): LifeCycle(application){
       init {
           onStarted {
               val prefService: PrefService by it.inject()
               val myMsgHandler: MsgHandler by it.inject()
               val myEventHandler: EventHandler by it.inject()

               prefService.findOfficialAccount()?.let {
                   application.install(OfficialAccountFeature) {
                       appId = it._id
                       secret = it.secret
                       encodingAESKey = it.aesKey
                       token = it.token
                       wechatId = it.wechatId
                       wechatName = it.name

                       msgHandler = myMsgHandler
                       eventHandler = myEventHandler                }
               }
           }
       }
   }

var clientLogConfigFunc: Logging.Config.() -> Unit = {
    logger = Logger.DEFAULT
    level = LogLevel.INFO
}

    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinx_serialization_version") // JVM dependency
    implementation("io.ktor:ktor-serialization:$ktor_version")
    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktor_version")

object ApiJson {
    //sealed class的子类通过classDiscriminator判断是哪个子类， kotlinx.serialization默认使用type
    //与正常的type字段冲突，kmongo/kbson 默认是___type，修改不生效。
    // 但使用___type, 与spring不兼容，spring中序列化时默认添加_class字段
    const val myClassDiscriminator = "_class"

    @OptIn(ExperimentalSerializationApi::class)
    fun JsonBuilder.apiJsonBuilder() {
        encodeDefaults = true
        explicitNulls = false
        ignoreUnknownKeys = true

        //输出给前端和前端提交的类型，可以为任意字符串，与kmongo/kbson无关，
        // 二者各使用各的classDiscriminator，都会转换成Java 对象实体
        //前端 <---ApiJson.serverSerializeJson---> Java对象实体 <---kmongo/kbson---> MongoDB bson存储
        // kmongo/kbson总是使用___type
        classDiscriminator = myClassDiscriminator
        //isLenient = true
        allowSpecialFloatingPointValues = true
        useArrayPolymorphism = false
    }
   
   ...
  
  }

/**
 * @param code identify the result type, generally it's OK or KO
 * @param msg error message if code is not OK
 * @param data payload of the result
 *
 * @param type showType: error display type： 0 silent; 1 message.warn; 2 message.error; 4 notification; 9 page
 * @param tId traceId: Convenient for back-end Troubleshooting: unique request ID
 * @param host Convenient for backend Troubleshooting: host of current access server
 *
 * About parameters: type, tId, host, please refer to: https://umijs.org/plugins/plugin-request
 * Custom serializers for a generic type
 * https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers-for-a-generic-type
 *
 * */
@Serializable
class DataBox<T>(
    val code: String,
    val msg: String? = null,
    val data: T? = null,
    var type: Int? = null,
    var tId: String? = null,
    var host: String? = null
)

ApplicationCall.respondBox(box: DataBox<T>)
ApplicationCall.respondBoxOK(data: T)
ApplicationCall.respondBoxKO(msg: String)
ApplicationCall.respondBoxJsonText(json: String)

class PostData(val data: String)//data 任意业务数据

/**
 * @param ids split by ","
 * @param action del, assign, updateStatus
 * @param arg1 parameter for action
 * @param arg1 parameter for action
 * */
@Serializable
class BatchOperationParams(
    val ids: String, //以 ","分隔的_id
    val action: String, //操作命令如： del, assign, updateStatus
    val arg1: String? = null, //提交的参数
    val arg2: String? = null //提交的参数
)

/**
 * 1 for acs
 * -1 for desc
 * */
object Sort {
    const val ASC = 1
    const val DESC = -1
}


/**
 * the type of sort key, receives from the client(front end),
 * includes: TypeNumber, TypeString, TypeObjectId
 * */
enum class SortKeyType{
 TypeNumber, TypeString, TypeObjectId
}


/**
 * front end show list, encode search parameters and pagination info: &umi=encodeURIComponent(pagination_and_sort_parameters:UmiPagination)
 * sever side get umi value,  using pagination to decode it and get UmiPagination info
 * */
interface IUmiPaginationParams{
    val umi: String?
    val pagination: UmiPagination
        get() = umi?.let { Json.decodeFromString(URLDecoder.decode(it,"UTF-8")) }?:UmiPagination()

    /**
     * convert search params to Bson(not include UmiPagination.lastIdFilter) for mongodb/Kmongo
     * */
    fun toFilter(): Bson{
        TODO("Not Implement")
    }
    
    /**
     * convert search params to SqlPagination for mysql/komapper
     * */
    fun toSqlPagination(): SqlPagination{
        TODO("Not Implement")
    }
}

/**
 * 一个service实现了对各个model的crud的处理，添加新的model时，需将model放到EnumMeta中
 * 若需自定义功能，可在子类中实现
 * */
open class BaseCrudService(cache: ICache): SqlGenericService(bizModule.dbName!!, cache)

SnowflakeId.getId()

//只选取部分字段
    fun findSkuOutlineList(params: SkuListParams): List<SkuOutlineBean>{
        val meta = Meta.goodsSku
        return db.runQuery{
            val pagination = params.toSqlPagination()

            (pagination.where?.let { QueryDsl.from(meta).where(it) }?:QueryDsl.from(meta))
                .orderBy(pagination.sort)
                .offset(pagination.offset)
                .limit(pagination.pageSize)
                .select(meta.id, meta.goodsId, meta.goodsName, meta.storeId, meta.storeName, meta.thumbnail, meta.createdAt)
        }.map{
            SkuOutlineBean(it[meta.id].toString(),it[meta.goodsId].toString(),
                it[meta.goodsName], it[meta.storeId].toString(),it[meta.storeName],it[meta.thumbnail],it[meta.createdAt])
        }
    }

@Serializable
@Resource("/skuList")
class SkuListParams(
    override val umi: String? = null,
    val id: String? = null,
    val goodsId:String? = null,
    val storeId: String? = null,
    val keyword: String? = null, //搜索关键字
) : IUmiPaginationParams {
    override fun toSqlPagination(): SqlPagination {
        val meta = Meta.goodsSku
        val lastId = pagination.lastId
        var lastW: WhereDeclaration? = null
        val sort: SortExpression
        
        when (pagination.sKey) {
            "createdAt" -> {
                val key = meta.createdAt
                sort = if (pagination.sort == Sort.DESC) key.desc() else key.asc()
                if (lastId != null) {
                    val lastT = lastId.toLong().utcToLocalDateTime()
                    lastW = if (pagination.sort == Sort.DESC) {
                        { key less lastT }
                    } else {
                        { key greater lastT }
                    }
                }
            }
            else -> {
                val key = meta.id
                sort = if (pagination.sort == Sort.DESC) key.desc() else key.asc()
                if (lastId != null) {
                    val lastT = lastId.toLong()
                    lastW = if (pagination.sort == Sort.DESC) {
                        { key less lastT }
                    } else {
                        { key greater lastT }
                    }
                }
            }
        }

        val w1: WhereDeclaration? = if(id != null) { { meta.id eq id.toLong() } } else null
        val w2: WhereDeclaration? = if(keyword != null) { { meta.goodsName like keyword } }else null
        val w3: WhereDeclaration? = goodsId?.let { { meta.goodsId eq it.toLong() }  }
        val w4: WhereDeclaration? = storeId?.let { { meta.storeId eq it.toLong() }  }
        
        //pageSize为-1时表示该查询条件下的全部数据
        return SqlPagination(sort, pagination.pageSize, (pagination.current - 1) * pagination.pageSize)
            .addWhere(w1, w3, w4, lastW, w2)
    }
}

//route中
get<CommentQueryParams>{
     call.respondBoxOK(commentController.findPage(it))
}

//controller中   
fun findPage(params: CommentQueryParams) = commentService.findPage(params)
        .map { it.toBean() }
        
//service中
fun findPage(params: CommentQueryParams) = findPage(Meta.comment, params.toSqlPagination())

@Resource("/list") //  /parameter/list
@Serializable
class ParameterQueryParams(
    override val umi: String? = null,
    val label: String? = null,
    val typeId: Int? = null,
    val key: String? = null
): IUmiPaginationParams {
    override fun toSqlPagination(): SqlPagination {
        val meta = Meta.parameter
        val lastId = pagination.lastId
        var lastW: WhereDeclaration? = null
        val sort: SortExpression

        //一般是根据pagination.sKey进行排序，但此处总是根据id进行排序
        val sortKey = meta.id
        sort = if (pagination.sort == Sort.DESC) sortKey.desc() else sortKey.asc()
        if (lastId != null) {
            val lastT = lastId.toInt()
            lastW = if (pagination.sort == Sort.DESC) {
                { sortKey less lastT }
            } else {
                { sortKey greater lastT }
            }
        }

        val w1: WhereDeclaration? = if(label != null) { { meta.label like label } } else null
        val w2: WhereDeclaration? = typeId?.let { { meta.typeId eq it }  }
        val w3: WhereDeclaration? = key?.let { { meta.key like it }  }

        //pageSize为-1时表示该查询条件下的全部数据
        return SqlPagination(sort, pagination.pageSize, (pagination.current - 1) * pagination.pageSize)
            .addWhere(w1, w2, w3, lastW)
    }
}

    //搜索接收的过滤参数
    @Location("/list")
    data class OrderInfoListParams(
        override val umi: String? = null,
        val _id: String? = null,
        val adder: String? = null, //添加人

        val pf: String? = null,
        val shopId: String? = null, //所属shop

        val product: String? = null,

        val name: String? = null, //收货人
        val tel: String? = null, //收货人
        val type: Int? = null,

        val appId: String? = null,

        val lastId: String? = null//必须为字符串类型，然后根据前端传递过来的类型信息，进行bson字符串的构建
    ): IUmiListParams { //实现IUmiListParams接口目的在于继承一个函数：将umi字符串转换成UmiPagination对象
        fun toFilter(): Bson {
            val idFilter = _id?.let { OrderInfo::_id eq it}

            val adderF = adder?.let { OrderInfo::adder eq it.toObjectId() }
            val pfFilter = pf?.let { OrderInfo::pf eq it }
            val shopIdF = shopId?.let { OrderInfo::shopId eq it.toObjectId() }
            val productF = product?.let { OrderInfo::product regex  (".*$it.*")}
            val nameF = name?.let { OrderInfo::name regex  (".*$it.*")}
            val telF = tel?.let { OrderInfo::tel eq it }
            val typeFilter = type?.let { OrderInfo::type eq it }
            val appIdF = appId?.let { OrderInfo::appId eq it }
            return and(idFilter, adderF, nameF, telF, shopIdF, productF, pfFilter,  typeFilter, appIdF)
        }
    }

        //后端路由 endpoint
        route("/orderInfo") {
                get<OrderInfoListParams> {
                    val list = service.findOrderInfoList(it.toFilter(), it.pagination, it.lastId)
                    call.respondBox(DataBox.ok(list))
                }
        }
        
        class Service{
         //所有的列表查询都一样，只需换掉对象示例OrderInfo，以及orderInfoCol
            fun findOrderInfoList(filter: Bson, pagination: UmiPagination, lastId: String?): List<OrderInfo> = runBlocking {
                    val sort =  pagination.sortJson.bson
                    if(lastId == null)
                        orderInfoCol.find(filter).skip((pagination.current - 1) * pagination.pageSize).limit(pagination.pageSize).sort(sort).toList()
                    else{
                        orderInfoCol.find(and(filter,pagination.lastIdFilter(lastId))).limit(pagination.pageSize).sort(sort).toList()
                    }
                }
        }
    

定义一个包括所有查询参数的data类，继承自IUmiPaginationParams，controller中可调用checkValid检查参数合法性：
```kotlin
/**
 * 列表过滤查询
 * @param _id 直接查询某个id
 * @param scope 属主范围
 * @param state 状态
 * @param uId  属主
 * @param tag 标签查询
 * @param keyword 关键字查询
 * @param lastId 上一条记录中最后一条的id，用于分页  Limitation： lastId只有在基于_id排序时才可正确地工作，而且只支持上下一页
 * */
@Serializable
@Resource("/list")
data class ArticleListParams(
        override val umi: String? = null,
        val _id: String? = null,
        val scope: Int? = null,
        val state: Int? = null,

        val uId: String? = null,
        val corpId: String? = null,

        val tag: String? = null,
        val keyword: String? = null,
        val lastId: String? = null,
        val outline: Int = 1 //不同的api
): IUmiPaginationParams {
    override fun toFilter(): Bson {
        val idFilter = _id?.let { Article::_id eq it.toObjectId() }
        val corpIdFilter = corpId?.let { Article::corpId eq it }

        //如果未指定scope，或指定为ALL，或指定为私有且指定了某个用户，都不做限制。对于最后一种情况私有个人素材，目的在于：即使充公了，也会在其个人上传列表里显示
        val scopeFilter = if(scope == null || scope == Article.SCOPE_ALL) null else  Article::scope eq scope
        val uIdFilter = uId?.let{Article::uId eq it.toObjectId()}

        val tagFilter = tag?.let{Article::tags.all(it) }
        val keywordFilter = keyword?.let { Article::title regex  (".*$it.*")}


        return if(outline == 1){
            //...
        }else{//for admin
            val stateFilter = state?.let { Article::state eq it }?:Article::state gt Constants.STATUS_DEL
            and(idFilter, uIdFilter, corpIdFilter,scopeFilter, stateFilter,tagFilter, keywordFilter)
        }
    }

    /**
     * 若参数合法性
     * */
    fun checkValid(): Boolean{
        //...
        return false
    }
}

    fun findList(filter: Bson, pagination: UmiPagination,lastId: String?): List<Article> = runBlocking {
        val sort =  pagination.sortJson.bson
        if(lastId == null)
            articleCol.find(filter).skip((pagination.current - 1) * pagination.pageSize).limit(pagination.pageSize).sort(sort).toList()
        else{
            articleCol.find(and(filter,pagination.lastIdFilter(lastId))).limit(pagination.pageSize).sort(sort).toList()
        }
    }

/**
 * pagination info, sort info, and filter key info
 * @param pageSize default 20
 * @param current starts from 1, not 0
 * @param sKey sort key.  mongodb example: "sorter":{"updatedAt":"ascend"} , the sort key is "updatedAt"
 * @param sort 1 for asc，-1 for desc, same as MongoDB
 * @param sKeyType the type of sKey
 * @param lastId the last value of sort key in current page when load more
 * @param fKey filter key
 * @param filters  items which contains values of filters, "filter":{"someKey":["value1",123,"value3"]}
 *
 * using var instead of val，aims to modify them for permission
 * */
@Serializable
class UmiPagination(
     var pageSize: Int = 10,
     var current: Int = 1,
     var sKey: String = "_id", //sortKey
     var sort: Int = Sort.DESC, //1用于升序，而-1用于降序
     val sKeyType: SortKeyType = SortKeyType.TypeObjectId,
     val lastId: String? = null,
     var fKey: String? = null, //filter key
     var filters: List<String>? = null
){
    /**
     * for mongodb/kmongo sort
     * */
    val sortJson = "{'${sKey}':${sort}}"

    /**
     * setup mongodb bson for pagination
     * new version: ignore the parameter. legacy: pass lastId in listSearchParams,
     * new version, lastId is in UmiPagination, legacy version it's in listSearchParams
     * @return mongodb bson
     * */
    fun lastIdFilter(): Bson? {
        if(lastId == null) return null
        val s = if(sort == Sort.DESC) "\$lt" else "\$gt"
        return when(sKeyType){
            SortKeyType.TypeNumber -> "{ '${sKey}': { $s: $lastId } }"
            SortKeyType.TypeString -> "{ '${sKey}': { $s: `$lastId` } }"
            SortKeyType.TypeObjectId -> "{ '${sKey}': { $s: ObjectId(\"${lastId.toObjectId().toHexString()}\") } }"
        }.bson
    }
}

class ArticleService(cache: ICache) : CacheService(cache){
    
    fun find(id: String) = cacheable("article/$id"){
        runBlocking {
            articleCol.findOneById(id.toObjectId())
        }
    }

    fun insert(doc: Article) = putable("article/${doc._id.to64String()}")
    {
        runBlocking { articleCol.insertOne(doc) }
        doc
    }
    
    fun deleteOne(id: String) = evict("article/$id"){
        runBlocking{
           articleCol.deleteOneById(id.toObjectId())
        }
    }
    fun batchDel(ids: List<String>) = batchEvict(ids.map { "article/$it" }){
        runBlocking {
           articleCol.deleteMany(Article::_id `in` ids.map { it.toObjectId() })
        }
   }
}

class AvatarService(cache: ICache): AbstractSqlService( cache) {
    override val dbSource: SqlDataSource = SqlDataSource("xcshopDB", "127.0.0.1", 3306, "root", "123456")

    fun saveAvatars(list: List<Avatar>) = batchSave(Meta.avatar, list, true)

    fun saveNicks(list: List<Nick>) = batchSave(Meta.nick, list, true)

    fun findAllNicks(w: WhereDeclaration) = findAll(Meta.nick, w)
    fun updateNick(id: Int, name: String) = db.runQuery {
        QueryDsl.update(Meta.nick).set {
            Meta.nick.name eq name
        }.where {
            Meta.nick.id eq id
        }
    }
    fun updateNick2(id: Int, name: String) = updateValues(Meta.nick,
        {Meta.nick.name eq name}, {Meta.nick.id eq id})

}

class AvatarPipeline: Pipeline {
    private val avatarService: AvatarService = AvatarService(VoidCache())

    override fun process(resultItems: ResultItems, task: Task) {
        //...
        if(list.isNotEmpty())
            avatarService.saveAvatars(list)
    }
    //...
}

/**
 * String的扩展函数： 是否是IP地址，只支持IPv4版本
 * */
fun String.isIp() : Boolean

/**
 * String的扩展函数： 是否是中国大陆手机号
 * */
fun String.isMobileNumber() : Boolean
/**
 *  是否是邮箱
 * */
fun String.isEmail(): Boolean

/**
 *  是否是http Url
 * */
fun String.isUrl(): Boolean

/**
 *  是否是身份证号码，不支持最后一位是字母？
 * */
fun String.IsIDCard(): Boolean


/**
 * 判断字符串中是否包含中文
 * @param str
 * 待校验字符串
 * @return 是否为中文
 * @warn 不能校验是否为中文标点符号
 *
 * find()方法是部分匹配，是查找输入串中与模式匹配的子串，如果该匹配的串有组还可以使用group()函数
 */
fun String.isContainChinese(): Boolean


/**
 * 是否含有非latin字符，即多字节字符
 * */
fun String.isContainMultiChar(): Boolean

/**
 * 校验字符是否是a-z、A-Z、_、0-9
 * @return true代表符合条件
 */
fun Char.isWord(): Boolean

/**
 * 校验一个字符是否是多字节字符
 * @return true代表是汉字
 */
fun Char.isMultiChar(): Boolean

/**
 * 判定输入的是否是: 中日韩文字及标点符号
 * @return true代表是汉字
 */
fun Char.isCJK(): Boolean


/**
 * 将127.0.0.1形式的IP地址转换成十进制数
 * */
fun String.ipv4ToLong(): Long?

/**
 *  将十进制整数形式转换成127.0.0.1形式的ip地址
 */
fun Long.toIPv4(): String

/**
 * 驼峰法转下划线
 */
fun String.camel2Underline(): String

LocalDateTime.toUtc()
Long.utcToLocalDateTime
Long.utcSecondsToLocalDateTime
Long.plusTime(years: Long = 0L, months: Long = 0L, days: Long = 0L) 

/**
 * nginx配置中，临时文件需要展示或下载，将这些文件放在某个目录下，前面加前缀如"/static/"，
 * nginx通过识别该路径将其解析到不同的静态资源root下面，如下面的配置：
 * location ^~ /static/ {
 *    root   /home/www/wxAdmin/cacheRoot;
 * }
 * 当前路径为：/home/www/wxAdmin/，用 . 代替
 * Root的路径值为："/home/www/wxAdmin/cacheRoot" 或 "./cacheRoot"
 * path为： "static"
 *
 * */
 * object NginxStaticRootUtil {

    /**
     * 用于配置和获取ROOT的相对路径
     * */
    const val RootKey = "Root"
    const val DefaultRootValue = "./cacheRoot"
    /**
     * 用于nginx进行路径识别
     * */
    const val StaticKey = "Path"
    const val DefaultStaticValue = "static"

    /**
     * 用于设置nginx配置中的root和static
     * */
    fun setRootAndStatic(root: String, path: String){
        System.setProperty(RootKey, root)
        System.setProperty(StaticKey, path)
    }
    /**
     * such as return ./cacheRoot when default
     * */
    fun nginxRoot() = System.getProperty(RootKey, DefaultRootValue)
    /**
     * such as return static when default
     * */
    fun nginxPath() = System.getProperty(StaticKey, DefaultStaticValue)
    /**
     * 生成文件时，用于生成完整的路径，不包含文件名
     * @param myPath 自己指定的路径的后半部分, 前后都无"/"
     * @return 返回完整的路径即 "$root/$static/$myPath"
     * */
    fun getTotalPath(myPath: String):String 

    /**
     * 用于返回网页可访问的路径，不包含文件名
     * @param myPath 自己指定的路径的后半部分, 前后都无"/"
     * @return 返回完整的路径即 "$root/$static/$myPath"
     * */
    fun getUrlPrefix(myPath: String):String 
}

   
   class UserRpcServer : IUser, KoinComponent {
       private val service: AccountService by inject()
   
       override fun updateAccountExpiration(
           uId: String?, oId: String, edition: Int, year: Int,
           month: Int, bonus: Int
       ): Boolean {
           //... //真正实现
       }
   }
   
   
   //启动时注册RPC：
   class UserSofaRpc(application: Application): SofaRpc(application){
       private val accountRpcServer: UserRpcServer by inject()
   
       override fun publicRpcService() { // publish service
           ProviderConfig<IUser>()
               .setInterfaceId(IUser::class.java.name)
               .setRef(accountRpcServer)
               .setServer(serverConfig)
               .setRegistry(registryConfig)
               .export()
       }

       override fun injectRpcClient() {}
   }

   class OrderController : KoinComponent {
       private val userClient: IUser by inject()
       //直接使用userClient
   }
   
   //启动时注册
   class OrderSofaRpc(application: Application) : SofaRpc(application) {
       override fun publicRpcService() {}
   
          override fun injectRpcClient() {
           val config = getConsumerConfig<IUser>()
           if(config != null){
               //https://start.insert-koin.io/#/getting-started/modules-definitions?id=module-amp-definitions
               loadKoinModules(module {
                   single<IUser> { config.refer() }
               })
           }
       }
   }