import {Application} from '@akajs/web'

const app: Application = new Application({})
export {app}

import {Application} from '@akajs/web'

const app: Application = new Application({
  autoBuild: false, // 不再自动初始化
})
// middleware
app.bodyParser()
app.requestLog()
app.assembleParameters()
app.buildMiddleware(requestLog)  // 自定义的中间件
app.formatResponse()
// app.statics()

// auto require
app.requireControllers()
// routers
app.buildRouters()
// koa.use(requestLog)
export {app}

import {userModule} from '../modules'

await userMoudle.findUser()

import {UserService} from './service/UserService'
import {Service, Inject} from '@akajs/core'

@Service('UserModule')
export class UserModule {
  @Inject('UserService')
  userService: UserService
}

import {Get, Controller, Inject} from '@akajs/core'
import {UserModule} from '../../user'

@Controller('/account')
export class AccountController {
  @Inject('UserModule')
  public userModule: UserModule

  @Get('/findUser')
  async findUser (ctx) {
    const {name} = ctx.parameters
    const user = await this.userModule.userService.findOneUserByName(name)
    ctx.body = user
  }
}

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

import {Controller, Get} from '@akajs/core'

@Controller('/user')
export class UserController {

  @Get('/hello/:name')
  async hello (ctx) {
    const {name} = ctx.params
    ctx.body = 'hello ' + name
  }
}

import {Controller, Get} from '@akajs/core'
import {logger} from '@akajs/utils'

const routerMiddleware = async function (ctx, next) {
  await next()
  if (isObject(ctx.body)) {
    ctx.body.info = 'inject from router middleware'
  }
}

@Controller(
  '/mid',
  async (ctx, next) => {
    logger.info('Hello from controller middleware!')
    ctx.set('Kalengo', 'inject form middleware')
    await next()
    // ctx.body.info = 'inject form middleware'
  })
export class MiddlewareController {

  @Get('/get', routerMiddleware)
  async get (ctx) {
    ctx.body = {name: 'hello'}
  }
}

export class WechatController {

   @inject(TYPES.BaseProxyImp)
   private wxProxy: IProxy

   async getOpenId (ctx: Context) {
     ctx.body = this.wxProxy.get()
   }
 }

container.bind<IProxy>(TYPES.BaseProxyImp).to(APoxy)

container.bind<IProxy>(TYPES.BaseProxyImp).to(BPoxy)

export class WechatController {
   private wxProxy = new AProxy()

   async getOpenId (ctx: Context) {
     ctx.body = this.wxProxy.get()
   }
 }

@CrudController('/user')
export class UserController implements ICurdController {

  @LazyInject('UserModel')
  public crudModel: UserModel
}

@Service('UserService')
export class UserService {
}

@Controller('/user')
export class UserController {

  @Inject('UserService')
  public userService: UserService
}

@Service()
export class UserService {
}

User.ts
```ts
@TypeMongoModel()
export class User {
}

export type UserModel = ReturnModelType<typeof User>

@Controller('/user')
export class UserController {

  @Autowired()
  public userService: UserService

  @Autowired()
  public userModel: UserModel
}

import {Length} from 'class-validator'

export class RegisterDto {
  @Length(10, 20)
  name?: string
  @Length(11, 11, {message: '手机号长度为11'})
  phone: string
}

@Controller('/user')
export class UserController {

  @Post('/register')
  async register (ctx: Context, @DTO(RegisterDto) dto) {
  }
}

@Controller('/user')
export class UserController {
  @Post('/register')
  async register (ctx: Context) {
       log('parametes', ctx.parametes)
  }
}

{
    code:0,
    message:'xxx',
    data:{}
}

import {IBaseMongoModel, MongoModel} from '@akajs/mongoose'

export interface IUser {
  phone: string
  name: string
}

export interface IUserModel extends IUser, Document {
  // registerSuccess (): IUserModelModel
}

export type UserModel = Model<IUserModel>

const schema: Schema = new Schema({
  phone: {type: String, index: true},
  name: {type: String}
})

@MongoModel('UserModel')
export class User implements IBaseMongoModel {
  modelName = 'User'
  schema = schema
}

import {TypeMongoModel} from '@akajs/mongoose'
import {ReturnModelType} from '@typegoose/typegoose'

@TypeMongoModel()
export class User {
  phone: string
  name: string
  count: number
}

export type RecordModel = ReturnModelType<typeof User>

import {initMongoose} from '@akajs/mongoose'
initMongoose()

@CrudController('/user')
export class UserController {

  @inject('UserModel')
  private crudModel: UserModel

  async hello(){
    const user = await this.crudModel.findOne({})
  }
}

import * as mongoose from 'mongoose'
import {Schema} from 'mongoose'
import * as assert from 'assert'
import {Transactional, getSession} from './decorators/Transactional'

mongoose.connect('mongodb://localhost:27017,localhost:27018,localhost:27019/test?replicaSet=rs', {useNewUrlParser: true})
mongoose.set('debug', true)
let db = mongoose.connection
const Customer = db.model('Customer', new Schema({name: String}))

class ClassA {
  @Transactional()
  async main (key) {
    await new Customer({name: 'ClassA'}).save({session: getSession()})
    const doc1 = await Customer.findOne({name: 'ClassA'})
    assert.ok(!doc1)
    await new ClassB().step2()
    return key
  }
}

class ClassB {
  async step2 () {
    const doc2 = await Customer.findOne({name: 'ClassA'}).session(getSession())
    assert.ok(doc2)
    await Customer.remove({}).session(getSession())
  }
}

new ClassA().main('aaa').then((res) => {
  console.log('res', res)
  mongoose.disconnect(console.log)
}).catch(console.error)

@CrudController('/user')
export class UserController {
  // 必须指定 crudModel
  @inject(TYPES.UserModel)
  private crudModel: UserModel
}

import {Application} from '@akajs/core'
import {initMongoose} from '@akajs/mongoose'

// mongoose 最好先导入, mognoose 链接 db 需要时间
initMongoose()
const app: Application = new Application({})
export {app}

import './service/UserService'

import { logger } from '@akajs/utils'

logger.info(`findOne ${this.crudModel.name} ${itemId}`)

import { logger } from '@akajs/utils'
const logger = LoggerFactory(config)

import {TypeMongoModel} from '@akajs/mongoose'
import {BaseLog} from '@akajs/web'

@TypeMongoModel('LogModel')
export class Log extends BaseLog {
}

const app: Application = new Application({
  requestLogToDB: true
})

import {logger,DateUtil} from '@akajs/utils'

logger.debug('hello', name)
// 两天后
DateUtil.getDayStart(null, 2)

module.exports = [
  {
    model: 'User',
    items: [
      {
        '_id': ObjectId('5b03b80c9b6c6043c138d1b6'),
        'phone': '13870399898',
        'name': 'HHHHb',
        'balance': 0,
        'isRegister': true
      }]
  }
]