func serve(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
if config.Debug() {
logs.Level(logs.DebugLevel)
}
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var app = application.New()
if app.Components["DB"], err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
app.Components["DB"].(*gorm.DB).AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
redisSettings, err := config.Redis()
client := redis.NewClient(&redis.Options{Addr: redisSettings.String()})
if _, err := client.Ping().Result(); err != nil {
return err
}
logs.Debug("Connected to Redis at %s", redisSettings.String())
app.Components["Redis"] = client
cfg := osin.NewServerConfig()
cfg.AllowedAuthorizeTypes = osin.AllowedAuthorizeType{osin.CODE, osin.TOKEN}
cfg.AllowedAccessTypes = osin.AllowedAccessType{osin.AUTHORIZATION_CODE,
osin.REFRESH_TOKEN, osin.PASSWORD}
oauthServer := osin.NewServer(cfg, components.NewRedisStorage(client))
app.Components["OAuth"] = oauthServer
app.Components["Templates"] = views.Templates()
app.Components["Mux"] = gojimux.New()
if config.Debug() {
app.Components["DB"].(*gorm.DB).LogMode(true)
app.Use(router.Logger)
}
app.Use(app.Apply)
app.Get("/oauth2/authorize", controllers.Authorize)
app.Post("/oauth2/token", controllers.Token)
app.Get("/oauth2/info", controllers.Info)
app.Post("/users/register", controllers.Register)
app.Get("/users/:id", controllers.RetrieveUser)
app.Get("/groups", controllers.RetrieveGroupCollection)
app.Post("/groups", controllers.CreateGroup)
app.Get("/groups/:id", controllers.RetrieveGroup)
app.Delete("/groups/:id", controllers.DeleteGroup)
app.Patch("/groups/:id", controllers.UpdateGroup)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
return app.Serve(server.String())
}
func add(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
var mail = ctx.String("mail")
var password = ctx.String("password")
var firstname = ctx.String("firstname")
var surname = ctx.String("surname")
var groupID = ctx.String("group")
if mail == "" || password == "" || firstname == "" || surname == "" {
logs.Error("All arguments are required")
return errors.New("all arguments are required")
}
passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
panic(err)
}
var convGroupID = 0
if groupID != "" {
convGroupID, err = strconv.Atoi(groupID)
if err != nil {
logs.Error(err)
return err
}
}
u := &models.User{
Mail: sPtr(mail),
Password: sPtr(string(passwordHash)),
Firstname: sPtr(firstname),
Surname: sPtr(surname),
GroupID: uint(convGroupID),
}
errs := u.Validate()
logs.Level(logs.DebugLevel)
if len(errs) > 0 {
logs.Error(errs)
return errors.New("Informations are not valid")
}
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var db *gorm.DB
if db, err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
db.AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
db.LogMode(true)
var store = models.UserStore(db)
err = store.Save(u)
if err != nil {
logs.Error(err)
return err
}
logs.Debug("New user :"******"-Mail : %s", mail)
logs.Debug("-Password : %s", password)
logs.Debug("-Firstname : %s", firstname)
logs.Debug("-Surname : %s", surname)
logs.Debug("-GroupID : %d", convGroupID)
return nil
}