kuuland / kuu

package main

import (
	"github.com/gin-gonic/gin"
	_ "github.com/jinzhu/gorm/dialects/postgres"
	"github.com/kuuland/kuu"
)

func main() {
	r := kuu.Default()
	r.Import(kuu.Acc(), kuu.Sys())
	r.Run()
}

func main() {
	kuu.C().Get("prefix")              // output "/api"
	kuu.C().GetBool("cors")            // output true
	kuu.C().GetBool("gorm:migrate")    // output true
    // load config from kuu.Param store on databases
	// only work when the Param.type is json and the Param.value is json object
    kuu.C().LoadFromParams("whitelist") // whitelist value is {"enable": true, "lable":"app", "items": ["item-1", "item-2"]}
	// and the key startwith: params
    kuu.C().GetBool("params.whilelist.enable") // output true
	kuu.C().GetString("params.whilelist.label") // output app
	var items []string
	kuu.C().GetInterface("params.whilelist.items", &items)
}

r.GET("/ping", func(c *kuu.Context) {
    var users []user
    kuu.DB().Find(&users)
    c.STD(&users)
})

r.GET("/ping", func(c *kuu.Context) {
    var users []user
    kuu.DB("ds1").Find(&users)
    c.STD(&users)
})

err := kuu.WithTransaction(func(tx *gorm.DB) error {
	// ...
    tx.Create(&memberDoc)
    if tx.NewRecord(memberDoc) {
        return errors.New("Failed to create member profile")
    }
    // ...
    tx.Create(...)
    return tx.Error
})

type User struct {
	kuu.Model `rest:"*"`
	Code string
	Name string
}

func main() {
	kuu.RESTful(r, &User{})
}

type User struct {
	kuu.Model
	Code string `rest:"*"`
	Name string
}

type User struct {
	kuu.Model `rest:"C:POST;U:PUT;R:GET;D:DELETE"`
	Code string
	Name string
}

func main() {
	kuu.RESTful(r, &User{})
}

type User struct {
	kuu.Model `rest:"*" route:"profile"`
	Code string
	Name string
}

func main() {
	kuu.RESTful(r, &User{})
}

type User struct {
	kuu.Model `rest:"C:-;U:PUT;R:GET;D:-"` // unmount all: `rest:"-"`
	Code string
	Name string
}

func main() {
	kuu.RESTful(r, &User{})
}

type User struct {
	Model   `rest:"*" displayName:"用户" kuu:"password"`
	Username    string  `name:"账号"`
	Password    string  `name:"密码"`
}

users := []User{
    {Username: "root", Password: "xxx"},
    {Username: "admin", Password: "xxx"},
} 
users = kuu.Meta("User").OmitPassword(users) // => []User{ { Username: "root" }, { Username: "admin" } } 

// Default create callback
kuu.CreateCallback = func(scope *gorm.Scope) {
	if !scope.HasError() {
		if desc := GetRoutinePrivilegesDesc(); desc != nil {
			var (
				hasOrgIDField       bool = false
				orgID               uint
				hasCreatedByIDField bool = false
				createdByID         uint
			)
			if field, ok := scope.FieldByName("OrgID"); ok {
				if field.IsBlank {
					if err := scope.SetColumn(field.DBName, desc.SignOrgID); err != nil {
						_ = scope.Err(fmt.Errorf("自动设置组织ID失败：%s", err.Error()))
						return
					}
				}
				hasOrgIDField = ok
				orgID = field.Field.Interface().(uint)
			}
			if field, ok := scope.FieldByName("CreatedByID"); ok {
				if err := scope.SetColumn(field.DBName, desc.UID); err != nil {
					_ = scope.Err(fmt.Errorf("自动设置创建人ID失败：%s", err.Error()))
					return
				}
				hasCreatedByIDField = ok
				createdByID = field.Field.Interface().(uint)
			}
			if field, ok := scope.FieldByName("UpdatedByID"); ok {
				if err := scope.SetColumn(field.DBName, desc.UID); err != nil {
					_ = scope.Err(fmt.Errorf("自动设置修改人ID失败：%s", err.Error()))
					return
				}
			}
			// 写权限判断
			if orgID == 0 {
				if hasCreatedByIDField && createdByID != desc.UID {
					_ = scope.Err(fmt.Errorf("用户 %d 只拥有个人可写权限", desc.UID))
					return
				}
			} else if hasOrgIDField && !desc.IsWritableOrgID(orgID) {
				_ = scope.Err(fmt.Errorf("用户 %d 在组织 %d 中无可写权限", desc.UID, orgID))
				return
			}
		}
	}
}


// Default delete callback
kuu.DeleteCallback = func(scope *gorm.Scope) {
	if !scope.HasError() {
		var extraOption string
		if str, ok := scope.Get("gorm:delete_option"); ok {
			extraOption = fmt.Sprint(str)
		}

		deletedAtField, hasDeletedAtField := scope.FieldByName("DeletedAt")
		var desc *PrivilegesDesc
		if desc = GetRoutinePrivilegesDesc(); desc != nil {
			AddDataScopeWritableSQL(scope, desc)
		}

		if !scope.Search.Unscoped && hasDeletedAtField {
			var sql string
			if desc != nil {
				deletedByField, hasDeletedByField := scope.FieldByName("DeletedByID")
				if !scope.Search.Unscoped && hasDeletedByField {
					sql = fmt.Sprintf(
						"UPDATE %v SET %v=%v,%v=%v%v%v",
						scope.QuotedTableName(),
						scope.Quote(deletedByField.DBName),
						scope.AddToVars(desc.UID),
						scope.Quote(deletedAtField.DBName),
						scope.AddToVars(gorm.NowFunc()),
						AddExtraSpaceIfExist(scope.CombinedConditionSql()),
						AddExtraSpaceIfExist(extraOption),
					)
				}
			}
			if sql == "" {
				sql = fmt.Sprintf(
					"UPDATE %v SET %v=%v%v%v",
					scope.QuotedTableName(),
					scope.Quote(deletedAtField.DBName),
					scope.AddToVars(gorm.NowFunc()),
					AddExtraSpaceIfExist(scope.CombinedConditionSql()),
					AddExtraSpaceIfExist(extraOption),
				)
			}
			scope.Raw(sql).Exec()
		} else {
			scope.Raw(fmt.Sprintf(
				"DELETE FROM %v%v%v",
				scope.QuotedTableName(),
				AddExtraSpaceIfExist(scope.CombinedConditionSql()),
				AddExtraSpaceIfExist(extraOption),
			)).Exec()
		}
		if scope.DB().RowsAffected < 1 {
			_ = scope.Err(errors.New("未删除任何记录，请检查更新条件或数据权限"))
			return
		}
	}
}

// Default update callback
kuu.UpdateCallback = func(scope *gorm.Scope) {
	if !scope.HasError() {
		if desc := GetRoutinePrivilegesDesc(); desc != nil {
			// 添加可写权限控制
			AddDataScopeWritableSQL(scope, desc)
			if err := scope.SetColumn("UpdatedByID", desc.UID); err != nil {
				ERROR("自动设置修改人ID失败：%s", err.Error())
			}
		}
	}
}

// Default query callback
kuu.QueryCallback = func(scope *gorm.Scope) {
	if !scope.HasError() {
		desc := GetRoutinePrivilegesDesc()
		if desc == nil {
			// 无登录登录态时
			return
		}

		caches := GetRoutineCaches()
		if caches != nil {
			// 有忽略标记时
			if _, ignoreAuth := caches[GLSIgnoreAuthKey]; ignoreAuth {
				return
			}
			// 查询用户菜单时
			if _, queryUserMenus := caches[GLSUserMenusKey]; queryUserMenus {
				if desc.NotRootUser() {
					_, hasCodeField := scope.FieldByName("Code")
					_, hasCreatedByIDField := scope.FieldByName("CreatedByID")
					if hasCodeField && hasCreatedByIDField {
						// 菜单数据权限控制与组织无关，且只有两种情况：
						// 1.自己创建的，一定看得到
						// 2.别人创建的，必须通过分配操作权限才能看到
						scope.Search.Where("(code in (?)) OR (created_by_id = ?)", desc.Codes, desc.UID)
					}
				}
				return
			}
		}
		AddDataScopeReadableSQL(scope, desc)
	}
}

// Default validate callback
kuu.ValidateCallback = func(scope *gorm.Scope) {
	if !scope.HasError() {
		if _, ok := scope.Get("gorm:update_column"); !ok {
			result, ok := scope.DB().Get(skipValidations)
			if !(ok && result.(bool)) {
				scope.CallMethod("Validate")
				if scope.Value == nil {
					return
				}
				resource := scope.IndirectValue().Interface()
				_, validatorErrors := govalidator.ValidateStruct(resource)
				if validatorErrors != nil {
					if errs, ok := validatorErrors.(govalidator.Errors); ok {
						for _, err := range FlatValidatorErrors(errs) {
							if err := scope.DB().AddError(formattedValidError(err, resource)); err != nil {
								ERROR("添加验证错误信息失败：%s", err.Error())
							}

						}
					} else {
						if err := scope.DB().AddError(validatorErrors); err != nil {
							ERROR("添加验证错误信息失败：%s", err.Error())
						}
					}
				}
			}
		}
	}
}

secret, err := kuu.GenToken(kuu.GenTokenDesc{
    Payload: jwt.MapClaims{
        "MemberID":  member.ID,
        "CreatedAt": member.CreatedAt,
    },
    UID:      member.UID,
    SubDocID: member.ID,
    Exp:      time.Now().Add(time.Second * time.Duration(kuu.ExpiresSeconds)).Unix(),
    Type:     "MY_SIGN_TYPE",
})

kuu.InjectCreateAuth = func(signType string, auth kuu.AuthProcessorDesc) (replace bool, err error) {
    return
}
kuu.InjectWritableAuth = func(signType string, auth kuu.AuthProcessorDesc) (replace bool, err error) {
    return
}
kuu.InjectReadableAuth = func(signType string, auth kuu.AuthProcessorDesc) (replace bool, err error) {
    return
}

// this struct definition will fail govalidator.ValidateStruct() (and the field values do not matter):
type exampleStruct struct {
  Name  string ``
  Email string `valid:"email"`
}

// this, however, will only fail when Email is empty or an invalid email address:
type exampleStruct2 struct {
  Name  string `valid:"-"`
  Email string `valid:"email"`
}

// lastly, this will only fail when Email is an invalid email address but not when it's empty:
type exampleStruct2 struct {
  Name  string `valid:"-"`
  Email string `valid:"email,optional"`
}

// Validate
func (e *exampleStruct2) Validate () error {
}

type User struct {
	kuu.Model `rest`
	Username string
	Password string
}

type Profile struct {
	kuu.Model `rest`
	Nickname string
	Age int
}

func MyMod() *kuu.Mod {
	return &kuu.Mod{
		Models: []interface{}{
			&User{},
			&Profile{},
		},
		Middlewares: gin.HandlersChain{
			func(c *gin.Context) {
				// Auth middleware
			},
		},
		Routes: kuu.RoutesInfo{
			kuu.RouteInfo{
				Method: "POST",
				Path:   "/login",
				HandlerFunc: func(c *kuu.Context) {
					// POST /login
				},
			},
			kuu.RouteInfo{
				Method: "POST",
				Path:   "/logout",
				HandlerFunc: func(c *kuu.Context) {
					// POST /logout
				},
			},
		},
	}
}

func main() {
	r := kuu.Default()
	r.Import(kuu.Acc(), kuu.Sys())     // import preset modules
	r.Import(MyMod())                       // import custom module
}

func main() {
	kuu.PRINT("Hello Kuu")  // PRINT[0000] Hello Kuu
	kuu.DEBUG("Hello Kuu")  // DEBUG[0000] Hello Kuu
	kuu.WARN("Hello Kuu")   // WARN[0000] Hello Kuu
	kuu.INFO("Hello Kuu")   // INFO[0000] Hello Kuu
	kuu.FATAL("Hello Kuu")  // FATAL[0000] Hello Kuu
	kuu.PANIC("Hello Kuu")  // PANIC[0000] Hello Kuu
}

func main() {
	kuu.INFO("Hello %s", "Kuu")  // INFO[0000] Hello Kuu
}

func main() {
	r := kuu.Default()
	r.GET("/ping", func(c *kuu.Context) {
        c.STD("hello")                                  // response: {"data":"hello","code":0}
        c.STD("hello", c.L("ping_success", "Success"))  // response: {"data":"hello","code":0,"msg":"Success"}
        c.STD(1800)                                     // response: {"data":1800,"code":0}
        c.STDErr(c.L("ping_failed_new", "New record failed"))       // response: {"code":-1,"msg":"New record failed"}
        c.STDErr(c.L("ping_failed_new", "New record failed"), err)  // response: {"code":-1,"msg":"New record failed","data":"错误详细描述信息，对应err.Error()"}
        c.STDErrHold(c.L("ping_failed_token", "Token decoding failed"), errors.New("token not found")).Code(555).Render() // response: {"code":555,"msg":"Token decoding failed","data":"token not found"}
    })
}

r.GET(func (c *kuu.Context){
	c.SignInfo // Login user info
	c.PrisDesc // Login user privileges
})

// preset caches
kuu.GetRoutinePrivilegesDesc()
kuu.GetRoutineValues()
kuu.GetRoutineRequestContext()

// custom caches
kuu.GetRoutineCaches()
kuu.SetRoutineCache(key, value)
kuu.GetRoutineCache(key)
kuu.DelRoutineCache(key)

// Ignore default data filters
kuu.IgnoreAuth() // Equivalent to c.IgnoreAuth/kuu.GetRoutineValues().IgnoreAuth

kuu.AddWhitelist("GET /", "GET /user")
kuu.AddWhitelist(regexp.MustCompile("/user"))

kuu.RegisterBizHook("User:BizBeforeCreate", func (scope *kuu.Scope) error {
    db := scope.DB // db instance
    user, ok := scope.Value.(*User)
	fmt.Println(user, ok)
    return nil
})

kuu.RegisterGormHook("User:BeforeSave", func(scope *gorm.Scope) error {
    return nil
})

kuu.L("acc_logout_failed", "Logout failed").Render()                             // => Logout failed
kuu.L("fano_table_total", "Total {{total}} items", kuu.M{"total": 500}).Render() // => Total 500 items

func singleMessage(c *kuu.Context) {
	failedMessage := c.L("import_failed", "Import failed")
	file, _ := c.FormFile("file")
	if file == nil {
		c.STDErr(failedMessage, errors.New("no 'file' key in form-data"))
		return
	}
	src, err := file.Open()
	if err != nil {
		c.STDErr(failedMessage, err)
		return
	}
	defer src.Close()
}

func multiMessage(c *kuu.Context) {
	var (
		phoneIncorrect = c.L("phone_incorrect", "Phone number is incorrect")
		passwordIncorrect = c.L("password_incorrect", "The password is incorrect")
	)
	if err := checkPhoneNumber(...); err != nil {
		c.STDErr(phoneIncorrect, err)
		return
	}
	if err := checkPassword(...); err != nil {
		c.STDErr(passwordIncorrect, err)
		return
	}
	c.STD(...)
}

register := kuu.NewLangRegister(kuu.DB())
register.SetKey("acc_please_login").Add("Please login", "请登录", "請登錄")
register.SetKey("auth_failed").Add("Authentication failed", "鉴权失败", "鑒權失敗")
register.SetKey("acc_logout_failed").Add("Logout failed", "登出失败", "登出失敗")
register.SetKey("kuu_welcome").Add("Welcome {{name}}", "欢迎{{name}}", "歡迎{{name}}")

func main() {
	r := kuu.Default()
	// Parse JSON from string
	var params map[string]string
	kuu.Parse(`{"user":"kuu","pass":"123"}`, &params)
	// Formatted as JSON
	kuu.Stringify(&params)
}