definition

var CaptchaDefinition = di.Def{
	Name:  "captcha",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return captcha.RecaptchaAdapter{}, nil
	},
}

var ContactRepositoryDefinition = di.Def{
	Name:  "contact-repository",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		r := repository.MysqlContactRepository{
			DbInstance: ctn.Get("database-entity").(database.IDbInstance),
			Logger:     ctn.Get("logger").(logger.ILogger),
		}
		return &r, nil
	},
}

var DatabaseDefinition = di.Def{
	Name:  "database",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		d := database.DbSQLInstance{
			Connection:   nil,
			Dsn:          ctn.Get("config").(config.IConfig).GetMysqlDsn(),
			DatabaseName: "",
			DriverName:   ctn.Get("config").(config.IConfig).GetDatabaseDriver(),
		}
		d.Connect()
		return &d, nil
	},
}

var DatabaseEntityDefinition = di.Def{
	Name:  "database-entity",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		d := database.DbSQLInstance{
			Connection:   nil,
			Dsn:          ctn.Get("config").(config.IConfig).GetMysqlDsn(),
			DatabaseName: ctn.Get("config").(config.IConfig).GetDatabaseName(),
			DriverName:   ctn.Get("config").(config.IConfig).GetDatabaseDriver(),
		}
		d.Connect()
		return &d, nil
	},
}

var DatabaseManagerDefinition = di.Def{
	Name:  "db-manager",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		d := database.DbMigration{
			DbInstance: ctn.Get("database-entity").(database.IDbInstance),
			RootPath:   ctn.Get("config").(config.IConfig).GetRootPath() + "/",
		}
		return d.New(), nil
	},
}

var IndexHandlerDefinition = di.Def{
	Name:  "index-handler",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return &handler.IndexHandler{
			Template:                    ctn.Get("templater").(templater.Templater),
			ListTechnoQueryHandler:      ctn.Get("list-techno-query-handler").(query.ListTechnoQueryHandler),
			RecaptchaSiteKey:            ctn.Get("config").(config.IConfig).GetRecaptchaSiteKey(),
			CreateContactCommandHandler: ctn.Get("create-contact-command-handler").(command.CreateContactCommandHandler),
			Session:                     ctn.Get("session").(session.Sessioner),
			Validation:                  ctn.Get("validation").(validation.ValidatorAdapter),
		}, nil
	},
}

var LoggerDefinition = di.Def{
	Name:  "logger",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return logger.ZapLoggerAdapter{
			RootPath: ctn.Get("config").(config.IConfig).GetRootPath() + "/",
			UseSugar: false,
		}.New()
	},
}

var MailerDefinition = di.Def{
	Name:  "mailer",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return &mailersmtp.MailerSMTP{
			RootPath: ctn.Get("config").(config.IConfig).GetRootPath() + "/",
			User:     ctn.Get("config").(config.IConfig).GetMailerUser(),
			Password: ctn.Get("config").(config.IConfig).GetMailerPassword(),
			Host:     "smtp.gmail.com",
			Port:     "587",
		}, nil
	},
}

var NotFoundHandlerDefinition = di.Def{
	Name:  "notfound-handler",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return &handler.NotFoundHandler{
			Template: ctn.Get("templater").(templater.Templater),
		}, nil
	},
}

var RouterDefinition = di.Def{
	Name:  "router",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		r := router.MuxRouterAdapter{
			MuxRouter: &mux.Router{},
		}
		return &r, nil
	},
}

var ServerDefinition = di.Def{
	Name:  "server",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		s := http.Server{
			Addr:    fmt.Sprintf(":%d", ctn.Get("config").(config.IConfig).GetAPIPort()),
			Handler: ctn.Get("router").(router.IRouter),
		}
		return &s, nil
	},
}

var SessionDefinition = di.Def{
	Name:  "session",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return session.SessionerAdapter{
			SessionKey: "medzoner-sessid",
			Store:      sessions.NewCookieStore([]byte("medzoner-sessid")),
		}, nil
	},
}

var TechnoHandlerDefinition = di.Def{
	Name:  "techno-handler",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return &handler.TechnoHandler{
			Template:               ctn.Get("templater").(templater.Templater),
			ListTechnoQueryHandler: ctn.Get("list-techno-query-handler").(query.ListTechnoQueryHandler),
		}, nil
	},
}

var TechnoRepositoryDefinition = di.Def{
	Name:  "techno-repository",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		r := repository.TechnoJSONRepository{
			Logger:   ctn.Get("logger").(logger.ILogger),
			RootPath: ctn.Get("config").(config.IConfig).GetRootPath(),
		}
		return &r, nil
	},
}

var TemplaterDefinition = di.Def{
	Name:  "templater",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return &templater.TemplateHTML{
			RootPath: ctn.Get("config").(config.IConfig).GetRootPath() + "/",
		}, nil
	},
}

var ValidationDefinition = di.Def{
	Name:  "validation",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return validation.ValidatorAdapter{
			ValidationErrors: validator.ValidationErrors{},
		}.New(), nil
	},
}

var WebDefinition = di.Def{
	Name:  "app-web",
	Scope: di.App,
	Build: func(ctn di.Container) (interface{}, error) {
		return &web.Web{
			Logger:             ctn.Get("logger").(logger.ILogger),
			Router:             ctn.Get("router").(router.IRouter),
			Server:             ctn.Get("server").(*http.Server),
			NotFoundHandler:    ctn.Get("notfound-handler").(*handler.NotFoundHandler),
			IndexHandler:       ctn.Get("index-handler").(*handler.IndexHandler),
			TechnoHandler:      ctn.Get("techno-handler").(*handler.TechnoHandler),
			APIPort:            ctn.Get("config").(config.IConfig).GetAPIPort(),
			RecaptchaSecretKey: ctn.Get("config").(config.IConfig).GetRecaptchaSecretKey(),
		}, nil
	},
}