mirror of
https://github.com/kataras/iris.git
synced 2025-12-24 05:17:03 +00:00
remove the old 'mvc' folder - examples are not changed yet - add the 'di' package inside the mvc2 package - which will be renamed to 'mvc' on the next commit - new mvc.Application and some dublications removed - The new version will be version 9 because it will contain breaking changes (not to the end-developer's controllers but to the API they register them) - get ready for 'Christmas Edition' for believers
Former-commit-id: c7114233dee90ee308c0a3e77ec2ad0c361094b8
This commit is contained in:
Gerasimos (Makis) Maropoulos
@@ -1,30 +0,0 @@
|
||||
package activator
|
||||
|
||||
// CallOnActivate simply calls the "controller"'s `OnActivate(*TController)` function,
|
||||
// if any.
|
||||
//
|
||||
// Look `activator.go#Register` and `ActivateListener` for more.
|
||||
func CallOnActivate(controller interface{}, tController *TController) {
|
||||
|
||||
if ac, ok := controller.(ActivateListener); ok {
|
||||
ac.OnActivate(tController)
|
||||
}
|
||||
}
|
||||
|
||||
// ActivateListener is an interface which should be declared
|
||||
// on a Controller which needs to register or change the bind values
|
||||
// that the caller-"user" has been passed to; via the `app.Controller`.
|
||||
// If that interface is completed by a controller
|
||||
// then the `OnActivate` function will be called ONCE, NOT in every request
|
||||
// but ONCE at the application's lifecycle.
|
||||
type ActivateListener interface {
|
||||
// OnActivate accepts a pointer to the `TController`.
|
||||
//
|
||||
// The `Controller` can make use of the `OnActivate` function
|
||||
// to register custom routes
|
||||
// or modify the provided values that will be binded to the
|
||||
// controller later on.
|
||||
//
|
||||
// Look `TController` for more.
|
||||
OnActivate(*TController)
|
||||
}
|
||||
@@ -1,346 +0,0 @@
|
||||
package activator
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/kataras/iris/core/router/macro"
|
||||
"github.com/kataras/iris/mvc/activator/methodfunc"
|
||||
"github.com/kataras/iris/mvc/activator/model"
|
||||
"github.com/kataras/iris/mvc/activator/persistence"
|
||||
|
||||
"github.com/kataras/golog"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/core/errors"
|
||||
)
|
||||
|
||||
type (
|
||||
// TController is the type of the controller,
|
||||
// it contains all the necessary information to load
|
||||
// and serve the controller to the outside world,
|
||||
// think it as a "supervisor" of your Controller which
|
||||
// cares about you.
|
||||
TController struct {
|
||||
// The name of the front controller struct.
|
||||
Name string
|
||||
// FullName it's the last package path segment + "." + the Name.
|
||||
// i.e: if login-example/user/controller.go, the FullName is "user.Controller".
|
||||
FullName string
|
||||
// the type of the user/dev's "c" controller (interface{}).
|
||||
Type reflect.Type
|
||||
// it's the first passed value of the controller instance,
|
||||
// we need this to collect and save the persistence fields' values.
|
||||
Value reflect.Value
|
||||
|
||||
valuePtr reflect.Value
|
||||
// // Methods and handlers, available after the Activate, can be seted `OnActivate` event as well.
|
||||
// Methods []methodfunc.MethodFunc
|
||||
|
||||
Router RegisterFunc
|
||||
|
||||
binder *binder // executed even before the BeginRequest if not nil.
|
||||
modelController *model.Controller
|
||||
persistenceController *persistence.Controller
|
||||
}
|
||||
)
|
||||
|
||||
// the parent package should complete this "interface"
|
||||
// it's not exported, so their functions
|
||||
// but reflect doesn't care about it, so we are ok
|
||||
// to compare the type of the base controller field
|
||||
// with this "ctrl", see `buildTypeInfo` and `buildMethodHandler`.
|
||||
|
||||
var (
|
||||
// ErrMissingControllerInstance is a static error which fired from `Controller` when
|
||||
// the passed "c" instnace is not a valid type of `Controller` or `C`.
|
||||
ErrMissingControllerInstance = errors.New("controller should have a field of mvc.Controller or mvc.C type")
|
||||
// ErrInvalidControllerType fired when the "Controller" field is not
|
||||
// the correct type.
|
||||
ErrInvalidControllerType = errors.New("controller instance is not a valid implementation")
|
||||
)
|
||||
|
||||
// BaseController is the controller interface,
|
||||
// which the main request `Controller` will implement automatically.
|
||||
// End-User doesn't need to have any knowledge of this if she/he doesn't want to implement
|
||||
// a new Controller type.
|
||||
// Controller looks the whole flow as one handler, so `ctx.Next`
|
||||
// inside `BeginRequest` is not be respected.
|
||||
// Alternative way to check if a middleware was procceed successfully
|
||||
// and called its `ctx.Next` is the `ctx.Proceed(handler) bool`.
|
||||
// You have to navigate to the `context/context#Proceed` function's documentation.
|
||||
type BaseController interface {
|
||||
SetName(name string)
|
||||
BeginRequest(ctx context.Context)
|
||||
EndRequest(ctx context.Context)
|
||||
}
|
||||
|
||||
// ActivateController returns a new controller type info description.
|
||||
func newController(base BaseController, router RegisterFunc) (*TController, error) {
|
||||
// get and save the type.
|
||||
typ := reflect.TypeOf(base)
|
||||
if typ.Kind() != reflect.Ptr {
|
||||
typ = reflect.PtrTo(typ)
|
||||
}
|
||||
|
||||
valPointer := reflect.ValueOf(base) // or value raw
|
||||
|
||||
// first instance value, needed to validate
|
||||
// the actual type of the controller field
|
||||
// and to collect and save the instance's persistence fields'
|
||||
// values later on.
|
||||
val := reflect.Indirect(valPointer)
|
||||
|
||||
ctrlName := val.Type().Name()
|
||||
pkgPath := val.Type().PkgPath()
|
||||
fullName := pkgPath[strings.LastIndexByte(pkgPath, '/')+1:] + "." + ctrlName
|
||||
|
||||
t := &TController{
|
||||
Name: ctrlName,
|
||||
FullName: fullName,
|
||||
Type: typ,
|
||||
Value: val,
|
||||
valuePtr: valPointer,
|
||||
Router: router,
|
||||
binder: &binder{elemType: typ.Elem()},
|
||||
modelController: model.Load(typ),
|
||||
persistenceController: persistence.Load(typ, val),
|
||||
}
|
||||
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// BindValueTypeExists returns true if at least one type of "bindValue"
|
||||
// is already binded to this `TController`.
|
||||
func (t *TController) BindValueTypeExists(bindValue interface{}) bool {
|
||||
valueTyp := reflect.TypeOf(bindValue)
|
||||
for _, bindedValue := range t.binder.values {
|
||||
// type already exists, remember: binding here is per-type.
|
||||
if typ := reflect.TypeOf(bindedValue); typ == valueTyp ||
|
||||
(valueTyp.Kind() == reflect.Interface && typ.Implements(valueTyp)) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// BindValue binds a value to a controller's field when request is served.
|
||||
func (t *TController) BindValue(bindValues ...interface{}) {
|
||||
for _, bindValue := range bindValues {
|
||||
t.binder.bind(bindValue)
|
||||
}
|
||||
}
|
||||
|
||||
// HandlerOf builds the handler for a type based on the specific method func.
|
||||
func (t *TController) HandlerOf(methodFunc methodfunc.MethodFunc) context.Handler {
|
||||
var (
|
||||
// shared, per-controller
|
||||
elem = t.Type.Elem()
|
||||
ctrlName = t.Name
|
||||
hasBinder = !t.binder.isEmpty()
|
||||
|
||||
hasPersistenceData = t.persistenceController != nil
|
||||
hasModels = t.modelController != nil
|
||||
// per-handler
|
||||
handleRequest = methodFunc.MethodCall
|
||||
)
|
||||
|
||||
return func(ctx context.Context) {
|
||||
// create a new controller instance of that type(>ptr).
|
||||
c := reflect.New(elem)
|
||||
if hasBinder {
|
||||
t.binder.handle(c)
|
||||
}
|
||||
|
||||
b := c.Interface().(BaseController)
|
||||
b.SetName(ctrlName)
|
||||
|
||||
// if has persistence data then set them
|
||||
// before the end-developer's handler in order to be available there.
|
||||
if hasPersistenceData {
|
||||
t.persistenceController.Handle(c)
|
||||
}
|
||||
|
||||
// if previous (binded) handlers stopped the execution
|
||||
// we should know that.
|
||||
if ctx.IsStopped() {
|
||||
return
|
||||
}
|
||||
|
||||
// init the request.
|
||||
b.BeginRequest(ctx)
|
||||
if ctx.IsStopped() { // if begin request stopped the execution
|
||||
return
|
||||
}
|
||||
|
||||
// the most important, execute the specific function
|
||||
// from the controller that is responsible to handle
|
||||
// this request, by method and path.
|
||||
handleRequest(ctx, c.Method(methodFunc.Index))
|
||||
// if had models, set them after the end-developer's handler.
|
||||
if hasModels {
|
||||
t.modelController.Handle(ctx, c)
|
||||
}
|
||||
|
||||
// end the request, don't check for stopped because this does the actual writing
|
||||
// if no response written already.
|
||||
b.EndRequest(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *TController) registerMethodFunc(m methodfunc.MethodFunc) {
|
||||
var middleware context.Handlers
|
||||
|
||||
if !t.binder.isEmpty() {
|
||||
if m := t.binder.middleware; len(m) > 0 {
|
||||
middleware = m
|
||||
}
|
||||
}
|
||||
|
||||
h := t.HandlerOf(m)
|
||||
if h == nil {
|
||||
golog.Warnf("MVC %s: nil method handler found for %s", t.FullName, m.Name)
|
||||
return
|
||||
}
|
||||
|
||||
registeredHandlers := append(middleware, h)
|
||||
t.Router(m.HTTPMethod, m.RelPath, registeredHandlers...)
|
||||
|
||||
golog.Debugf("MVC %s: %s %s maps to function[%d] '%s'", t.FullName,
|
||||
m.HTTPMethod,
|
||||
m.RelPath,
|
||||
m.Index,
|
||||
m.Name)
|
||||
}
|
||||
|
||||
func (t *TController) resolveAndRegisterMethods() {
|
||||
// the actual method functions
|
||||
// i.e for "GET" it's the `Get()`.
|
||||
methods, err := methodfunc.Resolve(t.Type)
|
||||
if err != nil {
|
||||
golog.Errorf("MVC %s: %s", t.FullName, err.Error())
|
||||
return
|
||||
}
|
||||
// range over the type info's method funcs,
|
||||
// build a new handler for each of these
|
||||
// methods and register them to their
|
||||
// http methods using the registerFunc, which is
|
||||
// responsible to convert these into routes
|
||||
// and add them to router via the APIBuilder.
|
||||
for _, m := range methods {
|
||||
t.registerMethodFunc(m)
|
||||
}
|
||||
}
|
||||
|
||||
// Handle registers a method func but with a custom http method and relative route's path,
|
||||
// it respects the rest of the controller's rules and guidelines.
|
||||
func (t *TController) Handle(httpMethod, path, handlerFuncName string) bool {
|
||||
cTyp := t.Type // with the pointer.
|
||||
m, exists := cTyp.MethodByName(handlerFuncName)
|
||||
if !exists {
|
||||
golog.Errorf("MVC: function '%s' doesn't exist inside the '%s' controller",
|
||||
handlerFuncName, t.FullName)
|
||||
return false
|
||||
}
|
||||
|
||||
info := methodfunc.FuncInfo{
|
||||
Name: m.Name,
|
||||
Trailing: m.Name,
|
||||
Type: m.Type,
|
||||
Index: m.Index,
|
||||
HTTPMethod: httpMethod,
|
||||
}
|
||||
|
||||
tmpl, err := macro.Parse(path, macro.NewMap())
|
||||
if err != nil {
|
||||
golog.Errorf("MVC: fail to parse the path for '%s.%s': %v", t.FullName, handlerFuncName, err)
|
||||
return false
|
||||
}
|
||||
|
||||
paramKeys := make([]string, len(tmpl.Params), len(tmpl.Params))
|
||||
for i, param := range tmpl.Params {
|
||||
paramKeys[i] = param.Name
|
||||
}
|
||||
|
||||
methodFunc, err := methodfunc.ResolveMethodFunc(info, paramKeys...)
|
||||
if err != nil {
|
||||
golog.Errorf("MVC: function '%s' inside the '%s' controller: %v", handlerFuncName, t.FullName, err)
|
||||
return false
|
||||
}
|
||||
|
||||
methodFunc.RelPath = path
|
||||
|
||||
t.registerMethodFunc(methodFunc)
|
||||
return true
|
||||
}
|
||||
|
||||
// func (t *TController) getMethodFuncByName(funcName string) (methodfunc.MethodFunc, bool) {
|
||||
// cVal := t.Value
|
||||
// cTyp := t.Type // with the pointer.
|
||||
// m, exists := cTyp.MethodByName(funcName)
|
||||
// if !exists {
|
||||
// golog.Errorf("MVC: function '%s' doesn't exist inside the '%s' controller",
|
||||
// funcName, cTyp.String())
|
||||
// return methodfunc.MethodFunc{}, false
|
||||
// }
|
||||
|
||||
// fn := cVal.MethodByName(funcName)
|
||||
// if !fn.IsValid() {
|
||||
// golog.Errorf("MVC: function '%s' inside the '%s' controller has not a valid value",
|
||||
// funcName, cTyp.String())
|
||||
// return methodfunc.MethodFunc{}, false
|
||||
// }
|
||||
|
||||
// info, ok := methodfunc.FetchFuncInfo(m)
|
||||
// if !ok {
|
||||
// golog.Errorf("MVC: could not resolve the func info from '%s'", funcName)
|
||||
// return methodfunc.MethodFunc{}, false
|
||||
// }
|
||||
|
||||
// methodFunc, err := methodfunc.ResolveMethodFunc(info)
|
||||
// if err != nil {
|
||||
// golog.Errorf("MVC: %v", err)
|
||||
// return methodfunc.MethodFunc{}, false
|
||||
// }
|
||||
|
||||
// return methodFunc, true
|
||||
// }
|
||||
|
||||
// // RegisterName registers a function by its name
|
||||
// func (t *TController) RegisterName(funcName string) bool {
|
||||
// methodFunc, ok := t.getMethodFuncByName(funcName)
|
||||
// if !ok {
|
||||
// return false
|
||||
// }
|
||||
// t.registerMethodFunc(methodFunc)
|
||||
// return true
|
||||
// }
|
||||
|
||||
// RegisterFunc used by the caller to register the result routes.
|
||||
type RegisterFunc func(httpMethod string, relPath string, handler ...context.Handler)
|
||||
|
||||
// Register receives a "controller",
|
||||
// a pointer of an instance which embeds the `Controller`,
|
||||
// the value of "baseControllerFieldName" should be `Controller`.
|
||||
func Register(controller BaseController, bindValues []interface{},
|
||||
registerFunc RegisterFunc) error {
|
||||
|
||||
t, err := newController(controller, registerFunc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
t.BindValue(bindValues...)
|
||||
|
||||
CallOnActivate(controller, t)
|
||||
|
||||
for _, bf := range t.binder.fields {
|
||||
golog.Debugf("MVC %s: binder loaded for '%s' with value:\n%#v",
|
||||
t.FullName, bf.GetFullName(), bf.GetValue())
|
||||
}
|
||||
|
||||
t.resolveAndRegisterMethods()
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -1,108 +0,0 @@
|
||||
package activator
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/kataras/iris/mvc/activator/field"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
)
|
||||
|
||||
// binder accepts a value of something
|
||||
// and tries to find its equalivent type
|
||||
// inside the controller and sets that to it,
|
||||
// after that each new instance of the controller will have
|
||||
// this value on the specific field, like persistence data control does.
|
||||
|
||||
type binder struct {
|
||||
elemType reflect.Type
|
||||
// values and fields are matched on the `match`.
|
||||
values []interface{}
|
||||
fields []field.Field
|
||||
|
||||
// saves any middleware that may need to be passed to the router,
|
||||
// statically, to gain performance.
|
||||
middleware context.Handlers
|
||||
}
|
||||
|
||||
func (b *binder) bind(value interface{}) {
|
||||
if value == nil {
|
||||
return
|
||||
}
|
||||
|
||||
b.values = append(b.values, value) // keep values.
|
||||
|
||||
b.match(value)
|
||||
}
|
||||
|
||||
func (b *binder) isEmpty() bool {
|
||||
// if nothing valid found return nil, so the caller
|
||||
// can omit the binder.
|
||||
if len(b.fields) == 0 && len(b.middleware) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func (b *binder) storeValueIfMiddleware(value reflect.Value) bool {
|
||||
if value.CanInterface() {
|
||||
if m, ok := value.Interface().(context.Handler); ok {
|
||||
b.middleware = append(b.middleware, m)
|
||||
return true
|
||||
}
|
||||
if m, ok := value.Interface().(func(context.Context)); ok {
|
||||
b.middleware = append(b.middleware, m)
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (b *binder) match(v interface{}) {
|
||||
value := reflect.ValueOf(v)
|
||||
// handlers will be recognised as middleware, not struct fields.
|
||||
// End-Developer has the option to call any handler inside
|
||||
// the controller's `BeginRequest` and `EndRequest`, the
|
||||
// state is respected from the method handler already.
|
||||
if b.storeValueIfMiddleware(value) {
|
||||
// stored as middleware, continue to the next field, we don't have
|
||||
// to bind anything here.
|
||||
return
|
||||
}
|
||||
|
||||
matcher := func(elemField reflect.StructField) bool {
|
||||
// If the controller's field is interface then check
|
||||
// if the given binded value implements that interface.
|
||||
// i.e MovieController { Service services.MovieService /* interface */ }
|
||||
// app.Controller("/", new(MovieController),
|
||||
// services.NewMovieMemoryService(...))
|
||||
//
|
||||
// `services.NewMovieMemoryService` returns a `*MovieMemoryService`
|
||||
// that implements the `MovieService` interface.
|
||||
if elemField.Type.Kind() == reflect.Interface {
|
||||
return value.Type().Implements(elemField.Type)
|
||||
}
|
||||
return elemField.Type == value.Type()
|
||||
}
|
||||
|
||||
handler := func(f *field.Field) {
|
||||
f.Value = value
|
||||
}
|
||||
|
||||
b.fields = append(b.fields, field.LookupFields(b.elemType, matcher, handler)...)
|
||||
}
|
||||
|
||||
func (b *binder) handle(c reflect.Value) {
|
||||
// we could make check for middlewares here but
|
||||
// these could easly be used outside of the controller
|
||||
// so we don't have to initialize a controller to call them
|
||||
// so they don't belong actually here, we will register them to the
|
||||
// router itself, before the controller's handler to gain performance,
|
||||
// look `activator.go#RegisterMethodHandlers` for more.
|
||||
|
||||
elem := c.Elem() // controller should always be a pointer at this state
|
||||
for _, f := range b.fields {
|
||||
f.SendTo(elem)
|
||||
}
|
||||
}
|
||||
@@ -1,220 +0,0 @@
|
||||
package field
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
)
|
||||
|
||||
// Field is a controller's field
|
||||
// contains all the necessary, internal, information
|
||||
// to work with.
|
||||
type Field struct {
|
||||
Name string // the field's original name
|
||||
// but if a tag with `name: "other"`
|
||||
// exist then this fill is filled, otherwise it's the same as the Name.
|
||||
TagName string
|
||||
Index int
|
||||
Type reflect.Type
|
||||
Value reflect.Value
|
||||
|
||||
embedded *Field
|
||||
}
|
||||
|
||||
// GetIndex returns all the "dimensions"
|
||||
// of the controller struct field's position that this field is referring to,
|
||||
// recursively.
|
||||
// Usage: elem.FieldByIndex(field.getIndex())
|
||||
// for example the {0,1} means that the field is on the second field of the first's
|
||||
// field of this struct.
|
||||
func (ff Field) GetIndex() []int {
|
||||
deepIndex := []int{ff.Index}
|
||||
|
||||
if emb := ff.embedded; emb != nil {
|
||||
deepIndex = append(deepIndex, emb.GetIndex()...)
|
||||
}
|
||||
|
||||
return deepIndex
|
||||
}
|
||||
|
||||
// GetType returns the type of the referring field, recursively.
|
||||
func (ff Field) GetType() reflect.Type {
|
||||
typ := ff.Type
|
||||
if emb := ff.embedded; emb != nil {
|
||||
return emb.GetType()
|
||||
}
|
||||
|
||||
return typ
|
||||
}
|
||||
|
||||
// GetFullName returns the full name of that field
|
||||
// i.e: UserController.SessionController.Manager,
|
||||
// it's useful for debugging only.
|
||||
func (ff Field) GetFullName() string {
|
||||
name := ff.Name
|
||||
|
||||
if emb := ff.embedded; emb != nil {
|
||||
return name + "." + emb.GetFullName()
|
||||
}
|
||||
|
||||
return name
|
||||
}
|
||||
|
||||
// GetTagName returns the tag name of the referring field
|
||||
// recursively.
|
||||
func (ff Field) GetTagName() string {
|
||||
name := ff.TagName
|
||||
|
||||
if emb := ff.embedded; emb != nil {
|
||||
return emb.GetTagName()
|
||||
}
|
||||
|
||||
return name
|
||||
}
|
||||
|
||||
// checkVal checks if that value
|
||||
// is valid to be set-ed to the new controller's instance.
|
||||
// Used on binder.
|
||||
func checkVal(val reflect.Value) bool {
|
||||
return val.IsValid() && (val.Kind() == reflect.Ptr && !val.IsNil()) && val.CanInterface()
|
||||
}
|
||||
|
||||
// GetValue returns a valid value of the referring field, recursively.
|
||||
func (ff Field) GetValue() interface{} {
|
||||
if ff.embedded != nil {
|
||||
return ff.embedded.GetValue()
|
||||
}
|
||||
|
||||
if checkVal(ff.Value) {
|
||||
return ff.Value.Interface()
|
||||
}
|
||||
|
||||
return "undefinied value"
|
||||
}
|
||||
|
||||
// SendTo should be used when this field or its embedded
|
||||
// has a Value on it.
|
||||
// It sets the field's value to the "elem" instance, it's the new controller.
|
||||
func (ff Field) SendTo(elem reflect.Value) {
|
||||
// note:
|
||||
// we don't use the getters here
|
||||
// because we do recursively search by our own here
|
||||
// to be easier to debug if ever needed.
|
||||
if embedded := ff.embedded; embedded != nil {
|
||||
if ff.Index >= 0 {
|
||||
embedded.SendTo(elem.Field(ff.Index))
|
||||
}
|
||||
return
|
||||
}
|
||||
elemField := elem.Field(ff.Index)
|
||||
if elemField.Kind() == reflect.Ptr && !elemField.IsNil() {
|
||||
return
|
||||
}
|
||||
|
||||
elemField.Set(ff.Value)
|
||||
}
|
||||
|
||||
// lookupTagName checks if the "elemField" struct's field
|
||||
// contains a tag `name`, if it contains then it returns its value
|
||||
// otherwise returns the field's original Name.
|
||||
func lookupTagName(elemField reflect.StructField) string {
|
||||
vname := elemField.Name
|
||||
|
||||
if taggedName, ok := elemField.Tag.Lookup("name"); ok {
|
||||
vname = taggedName
|
||||
}
|
||||
return vname
|
||||
}
|
||||
|
||||
// LookupFields iterates all "elem"'s fields and its fields
|
||||
// if structs, recursively.
|
||||
// Compares them to the "matcher", if they passed
|
||||
// then it executes the "handler" if any,
|
||||
// the handler can change the field as it wants to.
|
||||
//
|
||||
// It finally returns that collection of the valid fields, can be empty.
|
||||
func LookupFields(elem reflect.Type, matcher func(reflect.StructField) bool, handler func(*Field)) (fields []Field) {
|
||||
for i, n := 0, elem.NumField(); i < n; i++ {
|
||||
elemField := elem.Field(i)
|
||||
if matcher(elemField) {
|
||||
field := Field{
|
||||
Index: i,
|
||||
Name: elemField.Name,
|
||||
TagName: lookupTagName(elemField),
|
||||
Type: elemField.Type,
|
||||
}
|
||||
|
||||
if handler != nil {
|
||||
handler(&field)
|
||||
}
|
||||
|
||||
// we area inside the correct type
|
||||
fields = append(fields, field)
|
||||
continue
|
||||
}
|
||||
|
||||
f := lookupStructField(elemField.Type, matcher, handler)
|
||||
if f != nil {
|
||||
fields = append(fields, Field{
|
||||
Index: i,
|
||||
Name: elemField.Name,
|
||||
Type: elemField.Type,
|
||||
embedded: f,
|
||||
})
|
||||
}
|
||||
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// lookupStructField is here to search for embedded field only,
|
||||
// is working with the "lookupFields".
|
||||
// We could just one one function
|
||||
// for both structured (embedded) fields and normal fields
|
||||
// but we keep that as it's, a new function like this
|
||||
// is easier for debugging, if ever needed.
|
||||
func lookupStructField(elem reflect.Type, matcher func(reflect.StructField) bool, handler func(*Field)) *Field {
|
||||
// fmt.Printf("lookup struct for elem: %s\n", elem.Name())
|
||||
// ignore if that field is not a struct
|
||||
if elem.Kind() != reflect.Struct {
|
||||
return nil
|
||||
}
|
||||
|
||||
// search by fields.
|
||||
for i, n := 0, elem.NumField(); i < n; i++ {
|
||||
elemField := elem.Field(i)
|
||||
|
||||
if matcher(elemField) {
|
||||
// we area inside the correct type.
|
||||
f := &Field{
|
||||
Index: i,
|
||||
Name: elemField.Name,
|
||||
TagName: lookupTagName(elemField),
|
||||
Type: elemField.Type,
|
||||
}
|
||||
|
||||
if handler != nil {
|
||||
handler(f)
|
||||
}
|
||||
|
||||
return f
|
||||
}
|
||||
|
||||
// if field is struct and the value is struct
|
||||
// then try inside its fields for a compatible
|
||||
// field type.
|
||||
if elemField.Type.Kind() == reflect.Struct { // 3-level
|
||||
elemFieldEmb := elem.Field(i)
|
||||
f := lookupStructField(elemFieldEmb.Type, matcher, handler)
|
||||
if f != nil {
|
||||
fp := &Field{
|
||||
Index: i,
|
||||
Name: elemFieldEmb.Name,
|
||||
TagName: lookupTagName(elemFieldEmb),
|
||||
Type: elemFieldEmb.Type,
|
||||
embedded: f,
|
||||
}
|
||||
return fp
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
package methodfunc
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
)
|
||||
|
||||
// buildMethodCall builds the method caller.
|
||||
// We have repeated code here but it's the only way
|
||||
// to support more than one input arguments without performance cost compared to previous implementation.
|
||||
// so it's hard-coded written to check the length of input args and their types.
|
||||
func buildMethodCall(a *ast) func(ctx context.Context, f reflect.Value) {
|
||||
// if func input arguments are more than one then
|
||||
// use the Call method (slower).
|
||||
return func(ctx context.Context, f reflect.Value) {
|
||||
DispatchFuncResult(ctx, f.Call(a.paramValues(ctx)))
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
package methodfunc
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
var availableMethods = [...]string{
|
||||
"ANY", // will be registered using the `core/router#APIBuilder#Any`
|
||||
"ALL", // same as ANY
|
||||
"NONE", // offline route
|
||||
// valid http methods
|
||||
"GET",
|
||||
"POST",
|
||||
"PUT",
|
||||
"DELETE",
|
||||
"CONNECT",
|
||||
"HEAD",
|
||||
"PATCH",
|
||||
"OPTIONS",
|
||||
"TRACE",
|
||||
}
|
||||
|
||||
// FuncInfo is part of the `TController`,
|
||||
// it contains the index for a specific http method,
|
||||
// taken from user's controller struct.
|
||||
type FuncInfo struct {
|
||||
// Name is the map function name.
|
||||
Name string
|
||||
// Trailing is not empty when the Name contains
|
||||
// characters after the titled method, i.e
|
||||
// if Name = Get -> empty
|
||||
// if Name = GetLogin -> Login
|
||||
// if Name = GetUserPost -> UserPost
|
||||
Trailing string
|
||||
|
||||
// The Type of the method, includes the receivers.
|
||||
Type reflect.Type
|
||||
|
||||
// Index is the index of this function inside the controller type.
|
||||
Index int
|
||||
// HTTPMethod is the original http method that this
|
||||
// function should be registered to and serve.
|
||||
// i.e "GET","POST","PUT"...
|
||||
HTTPMethod string
|
||||
}
|
||||
|
||||
// or resolve methods
|
||||
func fetchInfos(typ reflect.Type) (methods []FuncInfo) {
|
||||
// search the entire controller
|
||||
// for any compatible method function
|
||||
// and add that.
|
||||
for i, n := 0, typ.NumMethod(); i < n; i++ {
|
||||
m := typ.Method(i)
|
||||
|
||||
if method, ok := FetchFuncInfo(m); ok {
|
||||
methods = append(methods, method)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FetchFuncInfo returns a FuncInfo based on the method of the controller.
|
||||
func FetchFuncInfo(m reflect.Method) (FuncInfo, bool) {
|
||||
name := m.Name
|
||||
|
||||
for _, method := range availableMethods {
|
||||
possibleMethodFuncName := methodTitle(method)
|
||||
|
||||
if strings.Index(name, possibleMethodFuncName) == 0 {
|
||||
trailing := ""
|
||||
// if has chars after the method itself
|
||||
if lname, lmethod := len(name), len(possibleMethodFuncName); lname > lmethod {
|
||||
ch := rune(name[lmethod])
|
||||
// if the next char is upper, otherise just skip the whole func info.
|
||||
if unicode.IsUpper(ch) {
|
||||
trailing = name[lmethod:]
|
||||
} else {
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
info := FuncInfo{
|
||||
Name: name,
|
||||
Trailing: trailing,
|
||||
Type: m.Type,
|
||||
HTTPMethod: method,
|
||||
Index: m.Index,
|
||||
}
|
||||
return info, true
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return FuncInfo{}, false
|
||||
}
|
||||
|
||||
func methodTitle(httpMethod string) string {
|
||||
httpMethodFuncName := strings.Title(strings.ToLower(httpMethod))
|
||||
return httpMethodFuncName
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
package methodfunc
|
||||
|
||||
import (
|
||||
"unicode"
|
||||
)
|
||||
|
||||
const (
|
||||
tokenBy = "By"
|
||||
tokenWildcard = "Wildcard" // should be followed by "By",
|
||||
)
|
||||
|
||||
// word lexer, not characters.
|
||||
type lexer struct {
|
||||
words []string
|
||||
cur int
|
||||
}
|
||||
|
||||
func newLexer(s string) *lexer {
|
||||
l := new(lexer)
|
||||
l.reset(s)
|
||||
return l
|
||||
}
|
||||
|
||||
func (l *lexer) reset(trailing string) {
|
||||
l.cur = -1
|
||||
var words []string
|
||||
if trailing != "" {
|
||||
end := len(trailing)
|
||||
start := -1
|
||||
|
||||
for i, n := 0, end; i < n; i++ {
|
||||
c := rune(trailing[i])
|
||||
if unicode.IsUpper(c) {
|
||||
// it doesn't count the last uppercase
|
||||
if start != -1 {
|
||||
end = i
|
||||
words = append(words, trailing[start:end])
|
||||
}
|
||||
start = i
|
||||
continue
|
||||
}
|
||||
end = i + 1
|
||||
}
|
||||
|
||||
if end > 0 && len(trailing) >= end {
|
||||
words = append(words, trailing[start:end])
|
||||
}
|
||||
}
|
||||
|
||||
l.words = words
|
||||
}
|
||||
|
||||
func (l *lexer) next() (w string) {
|
||||
cur := l.cur + 1
|
||||
|
||||
if w = l.peek(cur); w != "" {
|
||||
l.cur++
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (l *lexer) skip() {
|
||||
if cur := l.cur + 1; cur < len(l.words) {
|
||||
l.cur = cur
|
||||
} else {
|
||||
l.cur = len(l.words) - 1
|
||||
}
|
||||
}
|
||||
|
||||
func (l *lexer) peek(idx int) string {
|
||||
if idx < len(l.words) {
|
||||
return l.words[idx]
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (l *lexer) peekNext() (w string) {
|
||||
return l.peek(l.cur + 1)
|
||||
}
|
||||
|
||||
func (l *lexer) peekPrev() (w string) {
|
||||
if l.cur > 0 {
|
||||
cur := l.cur - 1
|
||||
w = l.words[cur]
|
||||
}
|
||||
|
||||
return w
|
||||
}
|
||||
@@ -1,213 +0,0 @@
|
||||
package methodfunc
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
)
|
||||
|
||||
var posWords = map[int]string{
|
||||
0: "",
|
||||
1: "first",
|
||||
2: "second",
|
||||
3: "third",
|
||||
4: "forth",
|
||||
5: "five",
|
||||
6: "sixth",
|
||||
7: "seventh",
|
||||
8: "eighth",
|
||||
9: "ninth",
|
||||
}
|
||||
|
||||
func genParamKey(argIdx int) string {
|
||||
return "param" + posWords[argIdx] // paramfirst, paramsecond...
|
||||
}
|
||||
|
||||
const (
|
||||
paramTypeInt = "int"
|
||||
paramTypeLong = "long"
|
||||
paramTypeBoolean = "boolean"
|
||||
paramTypeString = "string"
|
||||
paramTypePath = "path"
|
||||
)
|
||||
|
||||
var macroTypes = map[string]string{
|
||||
"int": paramTypeInt,
|
||||
"int64": paramTypeLong,
|
||||
"bool": paramTypeBoolean,
|
||||
"string": paramTypeString,
|
||||
// there is "path" param type but it's being captured "on-air"
|
||||
// "file" param type is not supported by the current implementation, yet
|
||||
// but if someone ask for it I'll implement it, it's easy.
|
||||
}
|
||||
|
||||
type funcParser struct {
|
||||
info FuncInfo
|
||||
lexer *lexer
|
||||
}
|
||||
|
||||
func newFuncParser(info FuncInfo) *funcParser {
|
||||
return &funcParser{
|
||||
info: info,
|
||||
lexer: newLexer(info.Trailing),
|
||||
}
|
||||
}
|
||||
|
||||
func (p *funcParser) parse() (*ast, error) {
|
||||
a := new(ast)
|
||||
funcArgPos := 0
|
||||
|
||||
for {
|
||||
w := p.lexer.next()
|
||||
if w == "" {
|
||||
break
|
||||
}
|
||||
|
||||
if w == tokenBy {
|
||||
funcArgPos++ // starting with 1 because in typ.NumIn() the first is the struct receiver.
|
||||
|
||||
// No need for these:
|
||||
// ByBy will act like /{param:type}/{param:type} as users expected
|
||||
// if func input arguments are there, else act By like normal path /by.
|
||||
//
|
||||
// if p.lexer.peekPrev() == tokenBy || typ.NumIn() == 1 { // ByBy, then act this second By like a path
|
||||
// a.relPath += "/" + strings.ToLower(w)
|
||||
// continue
|
||||
// }
|
||||
|
||||
if err := p.parsePathParam(a, w, funcArgPos); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
a.relPath += "/" + strings.ToLower(w)
|
||||
}
|
||||
|
||||
// This fixes a problem when developer misses to append the keyword `By`
|
||||
// to the method function when input arguments are declared (for path parameters binding).
|
||||
// We could just use it with `By` keyword but this is not a good practise
|
||||
// because what happens if we will become naive and declare something like
|
||||
// Get(id int) and GetBy(username string) or GetBy(id int) ? it's not working because of duplication of the path.
|
||||
// Docs are clear about that but we are humans, they may do a mistake by accident but
|
||||
// framework will not allow that.
|
||||
// So the best thing we can do to help prevent those errors is by printing that message
|
||||
// below to the developer.
|
||||
// Note: it should be at the end of the words loop because a.dynamic may be true later on.
|
||||
if numIn := p.info.Type.NumIn(); numIn > 1 && !a.dynamic {
|
||||
return nil, fmt.Errorf("found %d input arguments but keyword 'By' is missing from '%s'",
|
||||
// -1 because end-developer wants to know the actual input arguments, without the struct holder.
|
||||
numIn-1, p.info.Name)
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
func (p *funcParser) parsePathParam(a *ast, w string, funcArgPos int) error {
|
||||
typ := p.info.Type
|
||||
|
||||
if typ.NumIn() <= funcArgPos {
|
||||
// old:
|
||||
// return nil, errors.New("keyword 'By' found but length of input receivers are not match for " +
|
||||
// p.info.Name)
|
||||
|
||||
// By found but input arguments are not there, so act like /by path without restricts.
|
||||
a.relPath += "/" + strings.ToLower(w)
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
paramKey = genParamKey(funcArgPos) // paramfirst, paramsecond...
|
||||
paramType = paramTypeString // default string
|
||||
)
|
||||
|
||||
// string, int...
|
||||
goType := typ.In(funcArgPos).Name()
|
||||
nextWord := p.lexer.peekNext()
|
||||
|
||||
if nextWord == tokenWildcard {
|
||||
p.lexer.skip() // skip the Wildcard word.
|
||||
paramType = paramTypePath
|
||||
} else if pType, ok := macroTypes[goType]; ok {
|
||||
// it's not wildcard, so check base on our available macro types.
|
||||
paramType = pType
|
||||
} else {
|
||||
return errors.New("invalid syntax for " + p.info.Name)
|
||||
}
|
||||
|
||||
a.paramKeys = append(a.paramKeys, paramKey)
|
||||
a.paramTypes = append(a.paramTypes, paramType)
|
||||
// /{paramfirst:path}, /{paramfirst:long}...
|
||||
a.relPath += fmt.Sprintf("/{%s:%s}", paramKey, paramType)
|
||||
a.dynamic = true
|
||||
|
||||
if nextWord == "" && typ.NumIn() > funcArgPos+1 {
|
||||
// By is the latest word but func is expected
|
||||
// more path parameters values, i.e:
|
||||
// GetBy(name string, age int)
|
||||
// The caller (parse) doesn't need to know
|
||||
// about the incremental funcArgPos because
|
||||
// it will not need it.
|
||||
return p.parsePathParam(a, nextWord, funcArgPos+1)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type ast struct {
|
||||
paramKeys []string // paramfirst, paramsecond... [0]
|
||||
paramTypes []string // string, int, long, path... [0]
|
||||
relPath string
|
||||
dynamic bool // when paramKeys (and paramTypes, are equal) > 0
|
||||
}
|
||||
|
||||
// moved to func_caller#buildMethodcall, it's bigger and with repeated code
|
||||
// than this, below function but it's faster.
|
||||
// func (a *ast) MethodCall(ctx context.Context, f reflect.Value) {
|
||||
// if a.dynamic {
|
||||
// f.Call(a.paramValues(ctx))
|
||||
// return
|
||||
// }
|
||||
//
|
||||
// f.Interface().(func())()
|
||||
// }
|
||||
|
||||
func (a *ast) paramValues(ctx context.Context) []reflect.Value {
|
||||
if !a.dynamic {
|
||||
return nil
|
||||
}
|
||||
|
||||
l := len(a.paramKeys)
|
||||
values := make([]reflect.Value, l, l)
|
||||
|
||||
for i := 0; i < l; i++ {
|
||||
paramKey := a.paramKeys[i]
|
||||
paramType := a.paramTypes[i]
|
||||
values[i] = getParamValueFromType(ctx, paramType, paramKey)
|
||||
}
|
||||
|
||||
return values
|
||||
}
|
||||
|
||||
func getParamValueFromType(ctx context.Context, paramType string, paramKey string) reflect.Value {
|
||||
if paramType == paramTypeInt {
|
||||
v, _ := ctx.Params().GetInt(paramKey)
|
||||
return reflect.ValueOf(v)
|
||||
}
|
||||
|
||||
if paramType == paramTypeLong {
|
||||
v, _ := ctx.Params().GetInt64(paramKey)
|
||||
return reflect.ValueOf(v)
|
||||
}
|
||||
|
||||
if paramType == paramTypeBoolean {
|
||||
v, _ := ctx.Params().GetBool(paramKey)
|
||||
return reflect.ValueOf(v)
|
||||
}
|
||||
|
||||
// string, path...
|
||||
return reflect.ValueOf(ctx.Params().Get(paramKey))
|
||||
}
|
||||
@@ -1,230 +0,0 @@
|
||||
package methodfunc
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
)
|
||||
|
||||
// Result is a response dispatcher.
|
||||
// All types that complete this interface
|
||||
// can be returned as values from the method functions.
|
||||
type Result interface {
|
||||
// Dispatch should sends the response to the context's response writer.
|
||||
Dispatch(ctx context.Context)
|
||||
}
|
||||
|
||||
const slashB byte = '/'
|
||||
|
||||
type compatibleErr interface {
|
||||
Error() string
|
||||
}
|
||||
|
||||
// DefaultErrStatusCode is the default error status code (400)
|
||||
// when the response contains an error which is not nil.
|
||||
var DefaultErrStatusCode = 400
|
||||
|
||||
// DispatchErr writes the error to the response.
|
||||
func DispatchErr(ctx context.Context, status int, err error) {
|
||||
if status < 400 {
|
||||
status = DefaultErrStatusCode
|
||||
}
|
||||
ctx.StatusCode(status)
|
||||
if text := err.Error(); text != "" {
|
||||
ctx.WriteString(text)
|
||||
ctx.StopExecution()
|
||||
}
|
||||
}
|
||||
|
||||
// DispatchCommon is being used internally to send
|
||||
// commonly used data to the response writer with a smart way.
|
||||
func DispatchCommon(ctx context.Context,
|
||||
statusCode int, contentType string, content []byte, v interface{}, err error, found bool) {
|
||||
|
||||
// if we have a false boolean as a return value
|
||||
// then skip everything and fire a not found,
|
||||
// we even don't care about the given status code or the object or the content.
|
||||
if !found {
|
||||
ctx.NotFound()
|
||||
return
|
||||
}
|
||||
|
||||
status := statusCode
|
||||
if status == 0 {
|
||||
status = 200
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
DispatchErr(ctx, status, err)
|
||||
return
|
||||
}
|
||||
|
||||
// write the status code, the rest will need that before any write ofc.
|
||||
ctx.StatusCode(status)
|
||||
if contentType == "" {
|
||||
// to respect any ctx.ContentType(...) call
|
||||
// especially if v is not nil.
|
||||
contentType = ctx.GetContentType()
|
||||
}
|
||||
|
||||
if v != nil {
|
||||
if d, ok := v.(Result); ok {
|
||||
// write the content type now (internal check for empty value)
|
||||
ctx.ContentType(contentType)
|
||||
d.Dispatch(ctx)
|
||||
return
|
||||
}
|
||||
|
||||
if strings.HasPrefix(contentType, context.ContentJavascriptHeaderValue) {
|
||||
_, err = ctx.JSONP(v)
|
||||
} else if strings.HasPrefix(contentType, context.ContentXMLHeaderValue) {
|
||||
_, err = ctx.XML(v, context.XML{Indent: " "})
|
||||
} else {
|
||||
// defaults to json if content type is missing or its application/json.
|
||||
_, err = ctx.JSON(v, context.JSON{Indent: " "})
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
DispatchErr(ctx, status, err)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
ctx.ContentType(contentType)
|
||||
// .Write even len(content) == 0 , this should be called in order to call the internal tryWriteHeader,
|
||||
// it will not cost anything.
|
||||
ctx.Write(content)
|
||||
}
|
||||
|
||||
// DispatchFuncResult is being used internally to resolve
|
||||
// and send the method function's output values to the
|
||||
// context's response writer using a smart way which
|
||||
// respects status code, content type, content, custom struct
|
||||
// and an error type.
|
||||
// Supports for:
|
||||
// func(c *ExampleController) Get() string |
|
||||
// (string, string) |
|
||||
// (string, int) |
|
||||
// ...
|
||||
// int |
|
||||
// (int, string |
|
||||
// (string, error) |
|
||||
// ...
|
||||
// error |
|
||||
// (int, error) |
|
||||
// (customStruct, error) |
|
||||
// ...
|
||||
// bool |
|
||||
// (int, bool) |
|
||||
// (string, bool) |
|
||||
// (customStruct, bool) |
|
||||
// ...
|
||||
// customStruct |
|
||||
// (customStruct, int) |
|
||||
// (customStruct, string) |
|
||||
// Result or (Result, error) and so on...
|
||||
//
|
||||
// where Get is an HTTP METHOD.
|
||||
func DispatchFuncResult(ctx context.Context, values []reflect.Value) {
|
||||
numOut := len(values)
|
||||
if numOut == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
var (
|
||||
// if statusCode > 0 then send this status code.
|
||||
// Except when err != nil then check if status code is < 400 and
|
||||
// if it's set it as DefaultErrStatusCode.
|
||||
// Except when found == false, then the status code is 404.
|
||||
statusCode int
|
||||
// if not empty then use that as content type,
|
||||
// if empty and custom != nil then set it to application/json.
|
||||
contentType string
|
||||
// if len > 0 then write that to the response writer as raw bytes,
|
||||
// except when found == false or err != nil or custom != nil.
|
||||
content []byte
|
||||
// if not nil then check
|
||||
// for content type (or json default) and send the custom data object
|
||||
// except when found == false or err != nil.
|
||||
custom interface{}
|
||||
// if not nil then check for its status code,
|
||||
// if not status code or < 400 then set it as DefaultErrStatusCode
|
||||
// and fire the error's text.
|
||||
err error
|
||||
// if false then skip everything and fire 404.
|
||||
found = true // defaults to true of course, otherwise will break :)
|
||||
)
|
||||
|
||||
for _, v := range values {
|
||||
// order of these checks matters
|
||||
// for example, first we need to check for status code,
|
||||
// secondly the string (for content type and content)...
|
||||
if !v.IsValid() {
|
||||
continue
|
||||
}
|
||||
|
||||
f := v.Interface()
|
||||
|
||||
if b, ok := f.(bool); ok {
|
||||
found = b
|
||||
if !found {
|
||||
// skip everything, we don't care about other return values,
|
||||
// this boolean is the higher in order.
|
||||
break
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if i, ok := f.(int); ok {
|
||||
statusCode = i
|
||||
continue
|
||||
}
|
||||
|
||||
if s, ok := f.(string); ok {
|
||||
// a string is content type when it contains a slash and
|
||||
// content or custom struct is being calculated already;
|
||||
// (string -> content, string-> content type)
|
||||
// (customStruct, string -> content type)
|
||||
if (len(content) > 0 || custom != nil) && strings.IndexByte(s, slashB) > 0 {
|
||||
contentType = s
|
||||
} else {
|
||||
// otherwise is content
|
||||
content = []byte(s)
|
||||
}
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
if b, ok := f.([]byte); ok {
|
||||
// it's raw content, get the latest
|
||||
content = b
|
||||
continue
|
||||
}
|
||||
|
||||
if e, ok := f.(compatibleErr); ok {
|
||||
if e != nil { // it's always not nil but keep it here.
|
||||
err = e
|
||||
if statusCode < 400 {
|
||||
statusCode = DefaultErrStatusCode
|
||||
}
|
||||
break // break on first error, error should be in the end but we
|
||||
// need to know break the dispatcher if any error.
|
||||
// at the end; we don't want to write anything to the response if error is not nil.
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
// else it's a custom struct or a dispatcher, we'll decide later
|
||||
// because content type and status code matters
|
||||
// do that check in order to be able to correctly dispatch:
|
||||
// (customStruct, error) -> customStruct filled and error is nil
|
||||
if custom == nil && f != nil {
|
||||
custom = f
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
DispatchCommon(ctx, statusCode, contentType, content, custom, err, found)
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package methodfunc
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/core/errors"
|
||||
)
|
||||
|
||||
// MethodFunc the handler function.
|
||||
type MethodFunc struct {
|
||||
FuncInfo
|
||||
// MethodCall fires the actual handler.
|
||||
// The "ctx" is the current context, helps us to get any path parameter's values.
|
||||
//
|
||||
// The "f" is the controller's function which is responsible
|
||||
// for that request for this http method.
|
||||
// That function can accept one parameter.
|
||||
//
|
||||
// The default callers (and the only one for now)
|
||||
// are pre-calculated by the framework.
|
||||
MethodCall func(ctx context.Context, f reflect.Value)
|
||||
RelPath string
|
||||
}
|
||||
|
||||
// Resolve returns all the method funcs
|
||||
// necessary information and actions to
|
||||
// perform the request.
|
||||
func Resolve(typ reflect.Type) ([]MethodFunc, error) {
|
||||
r := errors.NewReporter()
|
||||
var methodFuncs []MethodFunc
|
||||
infos := fetchInfos(typ)
|
||||
for _, info := range infos {
|
||||
methodFunc, err := ResolveMethodFunc(info)
|
||||
if r.AddErr(err) {
|
||||
continue
|
||||
}
|
||||
methodFuncs = append(methodFuncs, methodFunc)
|
||||
}
|
||||
|
||||
return methodFuncs, r.Return()
|
||||
}
|
||||
|
||||
// ResolveMethodFunc resolves a single `MethodFunc` from a single `FuncInfo`.
|
||||
func ResolveMethodFunc(info FuncInfo, paramKeys ...string) (MethodFunc, error) {
|
||||
parser := newFuncParser(info)
|
||||
a, err := parser.parse()
|
||||
if err != nil {
|
||||
return MethodFunc{}, err
|
||||
}
|
||||
|
||||
if len(paramKeys) > 0 {
|
||||
a.paramKeys = paramKeys
|
||||
}
|
||||
|
||||
methodFunc := MethodFunc{
|
||||
RelPath: a.relPath,
|
||||
FuncInfo: info,
|
||||
MethodCall: buildMethodCall(a),
|
||||
}
|
||||
|
||||
/* TODO: split the method path and ast param keys, and all that
|
||||
because now we want to use custom param keys but 'paramfirst' is set-ed.
|
||||
|
||||
*/
|
||||
|
||||
return methodFunc, nil
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/kataras/iris/mvc/activator/field"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
)
|
||||
|
||||
// Controller is responsible
|
||||
// to load and handle the `Model(s)` inside a controller struct
|
||||
// via the `iris:"model"` tag field.
|
||||
// It stores the optional models from
|
||||
// the struct's fields values that
|
||||
// are being setted by the method function
|
||||
// and set them as ViewData.
|
||||
type Controller struct {
|
||||
fields []field.Field
|
||||
}
|
||||
|
||||
// Load tries to lookup and set for any valid model field.
|
||||
// Returns nil if no models are being used.
|
||||
func Load(typ reflect.Type) *Controller {
|
||||
matcher := func(f reflect.StructField) bool {
|
||||
if tag, ok := f.Tag.Lookup("iris"); ok {
|
||||
if tag == "model" {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
fields := field.LookupFields(typ.Elem(), matcher, nil)
|
||||
|
||||
if len(fields) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
mc := &Controller{
|
||||
fields: fields,
|
||||
}
|
||||
return mc
|
||||
}
|
||||
|
||||
// Handle transfer the models to the view.
|
||||
func (mc *Controller) Handle(ctx context.Context, c reflect.Value) {
|
||||
elem := c.Elem() // controller should always be a pointer at this state
|
||||
|
||||
for _, f := range mc.fields {
|
||||
|
||||
index := f.GetIndex()
|
||||
typ := f.GetType()
|
||||
name := f.GetTagName()
|
||||
|
||||
elemField := elem.FieldByIndex(index)
|
||||
// check if current controller's element field
|
||||
// is valid, is not nil and it's type is the same (should be but make that check to be sure).
|
||||
if !elemField.IsValid() ||
|
||||
(elemField.Kind() == reflect.Ptr && elemField.IsNil()) ||
|
||||
elemField.Type() != typ {
|
||||
continue
|
||||
}
|
||||
|
||||
fieldValue := elemField.Interface()
|
||||
ctx.ViewData(name, fieldValue)
|
||||
// /*maybe some time in the future*/ if resetable {
|
||||
// // clean up
|
||||
// elemField.Set(reflect.Zero(typ))
|
||||
// }
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
package persistence
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/kataras/iris/mvc/activator/field"
|
||||
)
|
||||
|
||||
// Controller is responsible to load from the original
|
||||
// end-developer's main controller's value
|
||||
// and re-store the persistence data by scanning the original.
|
||||
// It stores and sets to each new controller
|
||||
// the optional data that should be shared among all requests.
|
||||
type Controller struct {
|
||||
fields []field.Field
|
||||
}
|
||||
|
||||
// Load scans and load for persistence data based on the `iris:"persistence"` tag.
|
||||
//
|
||||
// The type is the controller's Type.
|
||||
// the "val" is the original end-developer's controller's Value.
|
||||
// Returns nil if no persistence data to store found.
|
||||
func Load(typ reflect.Type, val reflect.Value) *Controller {
|
||||
matcher := func(elemField reflect.StructField) bool {
|
||||
if tag, ok := elemField.Tag.Lookup("iris"); ok {
|
||||
if tag == "persistence" {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
handler := func(f *field.Field) {
|
||||
valF := val.Field(f.Index)
|
||||
if valF.IsValid() || (valF.Kind() == reflect.Ptr && !valF.IsNil()) {
|
||||
val := reflect.ValueOf(valF.Interface())
|
||||
if val.IsValid() || (val.Kind() == reflect.Ptr && !val.IsNil()) {
|
||||
f.Value = val
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fields := field.LookupFields(typ.Elem(), matcher, handler)
|
||||
|
||||
if len(fields) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &Controller{
|
||||
fields: fields,
|
||||
}
|
||||
}
|
||||
|
||||
// Handle re-stores the persistence data at the current controller.
|
||||
func (pc *Controller) Handle(c reflect.Value) {
|
||||
elem := c.Elem() // controller should always be a pointer at this state
|
||||
for _, f := range pc.fields {
|
||||
f.SendTo(elem)
|
||||
}
|
||||
}
|
||||
@@ -1,369 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/core/memstore"
|
||||
"github.com/kataras/iris/mvc/activator"
|
||||
)
|
||||
|
||||
// C is the lightweight BaseController type as an alternative of the `Controller` struct type.
|
||||
// It contains only the Name of the controller and the Context, it's the best option
|
||||
// to balance the performance cost reflection uses
|
||||
// if your controller uses the new func output values dispatcher feature;
|
||||
// func(c *ExampleController) Get() string |
|
||||
// (string, string) |
|
||||
// (string, int) |
|
||||
// int |
|
||||
// (int, string |
|
||||
// (string, error) |
|
||||
// bool |
|
||||
// (any, bool) |
|
||||
// error |
|
||||
// (int, error) |
|
||||
// (customStruct, error) |
|
||||
// customStruct |
|
||||
// (customStruct, int) |
|
||||
// (customStruct, string) |
|
||||
// Result or (Result, error)
|
||||
// where Get is an HTTP Method func.
|
||||
//
|
||||
// Look `core/router#APIBuilder#Controller` method too.
|
||||
//
|
||||
// It completes the `activator.BaseController` interface.
|
||||
//
|
||||
// Example at: https://github.com/kataras/iris/tree/master/_examples/mvc/overview/web/controllers.
|
||||
// Example usage at: https://github.com/kataras/iris/blob/master/mvc/method_result_test.go#L17.
|
||||
type C struct {
|
||||
// The Name of the `C` controller.
|
||||
Name string
|
||||
// The current context.Context.
|
||||
//
|
||||
// we have to name it for two reasons:
|
||||
// 1: can't ignore these via reflection, it doesn't give an option to
|
||||
// see if the functions is derived from another type.
|
||||
// 2: end-developer may want to use some method functions
|
||||
// or any fields that could be conflict with the context's.
|
||||
Ctx context.Context
|
||||
}
|
||||
|
||||
var _ activator.BaseController = &C{}
|
||||
|
||||
// SetName sets the controller's full name.
|
||||
// It's called internally.
|
||||
func (c *C) SetName(name string) { c.Name = name }
|
||||
|
||||
// BeginRequest starts the request by initializing the `Context` field.
|
||||
func (c *C) BeginRequest(ctx context.Context) { c.Ctx = ctx }
|
||||
|
||||
// EndRequest does nothing, is here to complete the `BaseController` interface.
|
||||
func (c *C) EndRequest(ctx context.Context) {}
|
||||
|
||||
// Controller is the base controller for the high level controllers instances.
|
||||
//
|
||||
// This base controller is used as an alternative way of building
|
||||
// APIs, the controller can register all type of http methods.
|
||||
//
|
||||
// Keep note that controllers are bit slow
|
||||
// because of the reflection use however it's as fast as possible because
|
||||
// it does preparation before the serve-time handler but still
|
||||
// remains slower than the low-level handlers
|
||||
// such as `Handle, Get, Post, Put, Delete, Connect, Head, Trace, Patch`.
|
||||
//
|
||||
//
|
||||
// All fields that are tagged with iris:"persistence"` or binded
|
||||
// are being persistence and kept the same between the different requests.
|
||||
//
|
||||
// An Example Controller can be:
|
||||
//
|
||||
// type IndexController struct {
|
||||
// Controller
|
||||
// }
|
||||
//
|
||||
// func (c *IndexController) Get() {
|
||||
// c.Tmpl = "index.html"
|
||||
// c.Data["title"] = "Index page"
|
||||
// c.Data["message"] = "Hello world!"
|
||||
// }
|
||||
//
|
||||
// Usage: app.Controller("/", new(IndexController))
|
||||
//
|
||||
//
|
||||
// Another example with bind:
|
||||
//
|
||||
// type UserController struct {
|
||||
// mvc.Controller
|
||||
//
|
||||
// DB *DB
|
||||
// CreatedAt time.Time
|
||||
// }
|
||||
//
|
||||
// // Get serves using the User controller when HTTP Method is "GET".
|
||||
// func (c *UserController) Get() {
|
||||
// c.Tmpl = "user/index.html"
|
||||
// c.Data["title"] = "User Page"
|
||||
// c.Data["username"] = "kataras " + c.Params.Get("userid")
|
||||
// c.Data["connstring"] = c.DB.Connstring
|
||||
// c.Data["uptime"] = time.Now().Sub(c.CreatedAt).Seconds()
|
||||
// }
|
||||
//
|
||||
// Usage: app.Controller("/user/{id:int}", new(UserController), db, time.Now())
|
||||
// Note: Binded values of context.Handler type are being recognised as middlewares by the router.
|
||||
//
|
||||
// Look `core/router/APIBuilder#Controller` method too.
|
||||
//
|
||||
// It completes the `activator.BaseController` interface.
|
||||
type Controller struct {
|
||||
// Name contains the current controller's full name.
|
||||
//
|
||||
// doesn't change on different paths.
|
||||
Name string
|
||||
|
||||
// contains the `Name` as different words, all lowercase,
|
||||
// without the "Controller" suffix if exists.
|
||||
// we need this as field because the activator
|
||||
// we will not try to parse these if not needed
|
||||
// it's up to the end-developer to call `RelPath()` or `RelTmpl()`
|
||||
// which will result to fill them.
|
||||
//
|
||||
// doesn't change on different paths.
|
||||
nameAsWords []string
|
||||
|
||||
// relPath the "as assume" relative request path.
|
||||
//
|
||||
// If UserController and request path is "/user/messages" then it's "/messages"
|
||||
// if UserPostController and request path is "/user/post" then it's "/"
|
||||
// if UserProfile and request path is "/user/profile/likes" then it's "/likes"
|
||||
//
|
||||
// doesn't change on different paths.
|
||||
relPath string
|
||||
|
||||
// request path and its parameters, read-write.
|
||||
// Path is the current request path, if changed then it redirects.
|
||||
Path string
|
||||
// Params are the request path's parameters, i.e
|
||||
// for route like "/user/{id}" and request to "/user/42"
|
||||
// it contains the "id" = 42.
|
||||
Params *context.RequestParams
|
||||
|
||||
// some info read and write,
|
||||
// can be already set-ed by previous handlers as well.
|
||||
Status int
|
||||
Values *memstore.Store
|
||||
|
||||
// relTmpl the "as assume" relative path to the view root folder.
|
||||
//
|
||||
// If UserController then it's "user/"
|
||||
// if UserPostController then it's "user/post/"
|
||||
// if UserProfile then it's "user/profile/".
|
||||
//
|
||||
// doesn't change on different paths.
|
||||
relTmpl string
|
||||
|
||||
// view read and write,
|
||||
// can be already set-ed by previous handlers as well.
|
||||
Layout string
|
||||
Tmpl string
|
||||
Data map[string]interface{}
|
||||
|
||||
ContentType string
|
||||
Text string // response as string
|
||||
|
||||
// give access to the request context itself.
|
||||
Ctx context.Context
|
||||
}
|
||||
|
||||
var _ activator.BaseController = &Controller{}
|
||||
|
||||
var ctrlSuffix = reflect.TypeOf(Controller{}).Name()
|
||||
|
||||
// SetName sets the controller's full name.
|
||||
// It's called internally.
|
||||
func (c *Controller) SetName(name string) {
|
||||
c.Name = name
|
||||
}
|
||||
|
||||
func (c *Controller) getNameWords() []string {
|
||||
if len(c.nameAsWords) == 0 {
|
||||
c.nameAsWords = findCtrlWords(c.Name)
|
||||
}
|
||||
return c.nameAsWords
|
||||
}
|
||||
|
||||
// Route returns the current request controller's context read-only access route.
|
||||
func (c *Controller) Route() context.RouteReadOnly {
|
||||
return c.Ctx.GetCurrentRoute()
|
||||
}
|
||||
|
||||
const slashStr = "/"
|
||||
|
||||
// RelPath tries to return the controller's name
|
||||
// without the "Controller" prefix, all lowercase
|
||||
// prefixed with slash and splited by slash appended
|
||||
// with the rest of the request path.
|
||||
// For example:
|
||||
// If UserController and request path is "/user/messages" then it's "/messages"
|
||||
// if UserPostController and request path is "/user/post" then it's "/"
|
||||
// if UserProfile and request path is "/user/profile/likes" then it's "/likes"
|
||||
//
|
||||
// It's useful for things like path checking and redirect.
|
||||
func (c *Controller) RelPath() string {
|
||||
if c.relPath == "" {
|
||||
w := c.getNameWords()
|
||||
rel := strings.Join(w, slashStr)
|
||||
|
||||
reqPath := c.Ctx.Path()
|
||||
if len(reqPath) == 0 {
|
||||
// it never come here
|
||||
// but to protect ourselves just return an empty slash.
|
||||
return slashStr
|
||||
}
|
||||
// [1:]to ellimuate the prefixes like "//"
|
||||
// request path has always "/"
|
||||
rel = strings.Replace(reqPath[1:], rel, "", 1)
|
||||
if rel == "" {
|
||||
rel = slashStr
|
||||
}
|
||||
c.relPath = rel
|
||||
// this will return any dynamic path after the static one
|
||||
// or a a slash "/":
|
||||
//
|
||||
// reqPath := c.Ctx.Path()
|
||||
// if len(reqPath) == 0 {
|
||||
// // it never come here
|
||||
// // but to protect ourselves just return an empty slash.
|
||||
// return slashStr
|
||||
// }
|
||||
// var routeVParams []string
|
||||
// c.Params.Visit(func(key string, value string) {
|
||||
// routeVParams = append(routeVParams, value)
|
||||
// })
|
||||
|
||||
// rel := c.Route().StaticPath()
|
||||
// println(rel)
|
||||
// // [1:]to ellimuate the prefixes like "//"
|
||||
// // request path has always "/"
|
||||
// rel = strings.Replace(reqPath, rel[1:], "", 1)
|
||||
// println(rel)
|
||||
// if rel == "" {
|
||||
// rel = slashStr
|
||||
// }
|
||||
// c.relPath = rel
|
||||
}
|
||||
|
||||
return c.relPath
|
||||
}
|
||||
|
||||
// RelTmpl tries to return the controller's name
|
||||
// without the "Controller" prefix, all lowercase
|
||||
// splited by slash and suffixed by slash.
|
||||
// For example:
|
||||
// If UserController then it's "user/"
|
||||
// if UserPostController then it's "user/post/"
|
||||
// if UserProfile then it's "user/profile/".
|
||||
//
|
||||
// It's useful to locate templates if the controller and views path have aligned names.
|
||||
func (c *Controller) RelTmpl() string {
|
||||
if c.relTmpl == "" {
|
||||
c.relTmpl = strings.Join(c.getNameWords(), slashStr) + slashStr
|
||||
}
|
||||
return c.relTmpl
|
||||
}
|
||||
|
||||
// Write writes to the client via the context's ResponseWriter.
|
||||
// Controller completes the `io.Writer` interface for the shake of ease.
|
||||
func (c *Controller) Write(contents []byte) (int, error) {
|
||||
c.tryWriteHeaders()
|
||||
return c.Ctx.ResponseWriter().Write(contents)
|
||||
}
|
||||
|
||||
// Writef formats according to a format specifier and writes to the response.
|
||||
func (c *Controller) Writef(format string, a ...interface{}) (int, error) {
|
||||
c.tryWriteHeaders()
|
||||
return c.Ctx.ResponseWriter().Writef(format, a...)
|
||||
}
|
||||
|
||||
// BeginRequest starts the main controller
|
||||
// it initialize the Ctx and other fields.
|
||||
//
|
||||
// It's called internally.
|
||||
// End-Developer can ovverride it but it still MUST be called.
|
||||
func (c *Controller) BeginRequest(ctx context.Context) {
|
||||
// path and path params
|
||||
c.Path = ctx.Path()
|
||||
c.Params = ctx.Params()
|
||||
// response status code
|
||||
c.Status = ctx.GetStatusCode()
|
||||
|
||||
// share values
|
||||
c.Values = ctx.Values()
|
||||
// view data for templates, remember
|
||||
// each controller is a new instance, so
|
||||
// checking for nil and then init those type of fields
|
||||
// have no meaning.
|
||||
c.Data = make(map[string]interface{}, 0)
|
||||
|
||||
// context itself
|
||||
c.Ctx = ctx
|
||||
}
|
||||
|
||||
func (c *Controller) tryWriteHeaders() {
|
||||
if c.Status > 0 && c.Status != c.Ctx.GetStatusCode() {
|
||||
c.Ctx.StatusCode(c.Status)
|
||||
}
|
||||
|
||||
if c.ContentType != "" {
|
||||
c.Ctx.ContentType(c.ContentType)
|
||||
}
|
||||
}
|
||||
|
||||
// EndRequest is the final method which will be executed
|
||||
// before response sent.
|
||||
//
|
||||
// It checks for the fields and calls the necessary context's
|
||||
// methods to modify the response to the client.
|
||||
//
|
||||
// It's called internally.
|
||||
// End-Developer can ovveride it but still should be called at the end.
|
||||
func (c *Controller) EndRequest(ctx context.Context) {
|
||||
if ctx.ResponseWriter().Written() >= 0 { // status code only (0) or actual body written(>0)
|
||||
return
|
||||
}
|
||||
|
||||
if path := c.Path; path != "" && path != ctx.Path() {
|
||||
// then redirect and exit.
|
||||
ctx.Redirect(path, c.Status)
|
||||
return
|
||||
}
|
||||
|
||||
c.tryWriteHeaders()
|
||||
if response := c.Text; response != "" {
|
||||
ctx.WriteString(response)
|
||||
return // exit here
|
||||
}
|
||||
|
||||
if view := c.Tmpl; view != "" {
|
||||
if layout := c.Layout; layout != "" {
|
||||
ctx.ViewLayout(layout)
|
||||
}
|
||||
if len(c.Data) > 0 {
|
||||
dataKey := ctx.Application().ConfigurationReadOnly().GetViewDataContextKey()
|
||||
// In order to respect any c.Ctx.ViewData that may called manually before;
|
||||
if ctx.Values().Get(dataKey) == nil {
|
||||
// if no c.Ctx.ViewData then it's empty do a
|
||||
// pure set, it's faster.
|
||||
ctx.Values().Set(dataKey, c.Data)
|
||||
} else {
|
||||
// else do a range loop and set the data one by one.
|
||||
for k, v := range c.Data {
|
||||
ctx.ViewData(k, v)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
ctx.View(view)
|
||||
}
|
||||
}
|
||||
@@ -1,531 +0,0 @@
|
||||
// black-box testing
|
||||
package mvc_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/kataras/iris"
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/mvc"
|
||||
"github.com/kataras/iris/mvc/activator"
|
||||
|
||||
"github.com/kataras/iris/core/router"
|
||||
"github.com/kataras/iris/httptest"
|
||||
)
|
||||
|
||||
type testController struct {
|
||||
mvc.Controller
|
||||
}
|
||||
|
||||
var writeMethod = func(c mvc.Controller) {
|
||||
c.Ctx.Writef(c.Ctx.Method())
|
||||
}
|
||||
|
||||
func (c *testController) Get() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Post() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Put() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Delete() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Connect() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Head() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Patch() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Options() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
func (c *testController) Trace() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
|
||||
type (
|
||||
testControllerAll struct{ mvc.Controller }
|
||||
testControllerAny struct{ mvc.Controller } // exactly the same as All
|
||||
)
|
||||
|
||||
func (c *testControllerAll) All() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
|
||||
func (c *testControllerAny) Any() {
|
||||
writeMethod(c.Controller)
|
||||
}
|
||||
|
||||
func TestControllerMethodFuncs(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/", new(testController))
|
||||
app.Controller("/all", new(testControllerAll))
|
||||
app.Controller("/any", new(testControllerAny))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
for _, method := range router.AllMethods {
|
||||
|
||||
e.Request(method, "/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(method)
|
||||
|
||||
e.Request(method, "/all").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(method)
|
||||
|
||||
e.Request(method, "/any").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(method)
|
||||
}
|
||||
}
|
||||
|
||||
func TestControllerMethodAndPathHandleMany(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/ /path1 /path2 /path3", new(testController))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
for _, method := range router.AllMethods {
|
||||
|
||||
e.Request(method, "/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(method)
|
||||
|
||||
e.Request(method, "/path1").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(method)
|
||||
|
||||
e.Request(method, "/path2").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(method)
|
||||
}
|
||||
}
|
||||
|
||||
type testControllerPersistence struct {
|
||||
mvc.Controller
|
||||
Data string `iris:"persistence"`
|
||||
}
|
||||
|
||||
func (c *testControllerPersistence) Get() {
|
||||
c.Ctx.WriteString(c.Data)
|
||||
}
|
||||
|
||||
func TestControllerPersistenceFields(t *testing.T) {
|
||||
data := "this remains the same for all requests"
|
||||
app := iris.New()
|
||||
app.Controller("/", &testControllerPersistence{Data: data})
|
||||
e := httptest.New(t, app)
|
||||
e.GET("/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(data)
|
||||
}
|
||||
|
||||
type testControllerBeginAndEndRequestFunc struct {
|
||||
mvc.Controller
|
||||
|
||||
Username string
|
||||
}
|
||||
|
||||
// called before of every method (Get() or Post()).
|
||||
//
|
||||
// useful when more than one methods using the
|
||||
// same request values or context's function calls.
|
||||
func (c *testControllerBeginAndEndRequestFunc) BeginRequest(ctx context.Context) {
|
||||
c.Controller.BeginRequest(ctx)
|
||||
c.Username = ctx.Params().Get("username")
|
||||
// or t.Params.Get("username") because the
|
||||
// t.Ctx == ctx and is being initialized at the t.Controller.BeginRequest.
|
||||
}
|
||||
|
||||
// called after every method (Get() or Post()).
|
||||
func (c *testControllerBeginAndEndRequestFunc) EndRequest(ctx context.Context) {
|
||||
ctx.Writef("done") // append "done" to the response
|
||||
c.Controller.EndRequest(ctx)
|
||||
}
|
||||
|
||||
func (c *testControllerBeginAndEndRequestFunc) Get() {
|
||||
c.Ctx.Writef(c.Username)
|
||||
}
|
||||
|
||||
func (c *testControllerBeginAndEndRequestFunc) Post() {
|
||||
c.Ctx.Writef(c.Username)
|
||||
}
|
||||
|
||||
func TestControllerBeginAndEndRequestFunc(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/profile/{username}", new(testControllerBeginAndEndRequestFunc))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
usernames := []string{
|
||||
"kataras",
|
||||
"makis",
|
||||
"efi",
|
||||
"rg",
|
||||
"bill",
|
||||
"whoisyourdaddy",
|
||||
}
|
||||
doneResponse := "done"
|
||||
|
||||
for _, username := range usernames {
|
||||
e.GET("/profile/" + username).Expect().Status(iris.StatusOK).
|
||||
Body().Equal(username + doneResponse)
|
||||
e.POST("/profile/" + username).Expect().Status(iris.StatusOK).
|
||||
Body().Equal(username + doneResponse)
|
||||
}
|
||||
}
|
||||
|
||||
func TestControllerBeginAndEndRequestFuncBindMiddleware(t *testing.T) {
|
||||
app := iris.New()
|
||||
usernames := map[string]bool{
|
||||
"kataras": true,
|
||||
"makis": false,
|
||||
"efi": true,
|
||||
"rg": false,
|
||||
"bill": true,
|
||||
"whoisyourdaddy": false,
|
||||
}
|
||||
middlewareCheck := func(ctx context.Context) {
|
||||
for username, allow := range usernames {
|
||||
if ctx.Params().Get("username") == username && allow {
|
||||
ctx.Next()
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
ctx.StatusCode(iris.StatusForbidden)
|
||||
ctx.Writef("forbidden")
|
||||
}
|
||||
|
||||
app.Controller("/profile/{username}", new(testControllerBeginAndEndRequestFunc), middlewareCheck)
|
||||
|
||||
e := httptest.New(t, app)
|
||||
|
||||
doneResponse := "done"
|
||||
|
||||
for username, allow := range usernames {
|
||||
getEx := e.GET("/profile/" + username).Expect()
|
||||
if allow {
|
||||
getEx.Status(iris.StatusOK).
|
||||
Body().Equal(username + doneResponse)
|
||||
} else {
|
||||
getEx.Status(iris.StatusForbidden).Body().Equal("forbidden")
|
||||
}
|
||||
|
||||
postEx := e.POST("/profile/" + username).Expect()
|
||||
if allow {
|
||||
postEx.Status(iris.StatusOK).
|
||||
Body().Equal(username + doneResponse)
|
||||
} else {
|
||||
postEx.Status(iris.StatusForbidden).Body().Equal("forbidden")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Model struct {
|
||||
Username string
|
||||
}
|
||||
|
||||
type testControllerModel struct {
|
||||
mvc.Controller
|
||||
|
||||
TestModel Model `iris:"model" name:"myModel"`
|
||||
TestModel2 Model `iris:"model"`
|
||||
}
|
||||
|
||||
func (c *testControllerModel) Get() {
|
||||
username := c.Ctx.Params().Get("username")
|
||||
c.TestModel = Model{Username: username}
|
||||
c.TestModel2 = Model{Username: username + "2"}
|
||||
}
|
||||
|
||||
func writeModels(ctx context.Context, names ...string) {
|
||||
if expected, got := len(names), len(ctx.GetViewData()); expected != got {
|
||||
ctx.Writef("expected view data length: %d but got: %d for names: %s", expected, got, names)
|
||||
return
|
||||
}
|
||||
|
||||
for _, name := range names {
|
||||
|
||||
m, ok := ctx.GetViewData()[name]
|
||||
if !ok {
|
||||
ctx.Writef("fail load and set the %s", name)
|
||||
return
|
||||
}
|
||||
|
||||
model, ok := m.(Model)
|
||||
if !ok {
|
||||
ctx.Writef("fail to override the %s' name by the tag", name)
|
||||
return
|
||||
}
|
||||
|
||||
ctx.Writef(model.Username)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *testControllerModel) EndRequest(ctx context.Context) {
|
||||
writeModels(ctx, "myModel", "TestModel2")
|
||||
c.Controller.EndRequest(ctx)
|
||||
}
|
||||
func TestControllerModel(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/model/{username}", new(testControllerModel))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
usernames := []string{
|
||||
"kataras",
|
||||
"makis",
|
||||
}
|
||||
|
||||
for _, username := range usernames {
|
||||
e.GET("/model/" + username).Expect().Status(iris.StatusOK).
|
||||
Body().Equal(username + username + "2")
|
||||
}
|
||||
}
|
||||
|
||||
type testBindType struct {
|
||||
title string
|
||||
}
|
||||
|
||||
type testControllerBindStruct struct {
|
||||
mvc.Controller
|
||||
// should start with upper letter of course
|
||||
TitlePointer *testBindType // should have the value of the "myTitlePtr" on test
|
||||
TitleValue testBindType // should have the value of the "myTitleV" on test
|
||||
Other string // just another type to check the field collection, should be empty
|
||||
}
|
||||
|
||||
func (t *testControllerBindStruct) Get() {
|
||||
t.Ctx.Writef(t.TitlePointer.title + t.TitleValue.title + t.Other)
|
||||
}
|
||||
|
||||
type testControllerBindDeep struct {
|
||||
testControllerBindStruct
|
||||
}
|
||||
|
||||
func (t *testControllerBindDeep) Get() {
|
||||
// t.testControllerBindStruct.Get()
|
||||
t.Ctx.Writef(t.TitlePointer.title + t.TitleValue.title + t.Other)
|
||||
}
|
||||
func TestControllerBind(t *testing.T) {
|
||||
app := iris.New()
|
||||
// app.Logger().SetLevel("debug")
|
||||
|
||||
t1, t2 := "my pointer title", "val title"
|
||||
// test bind pointer to pointer of the correct type
|
||||
myTitlePtr := &testBindType{title: t1}
|
||||
// test bind value to value of the correct type
|
||||
myTitleV := testBindType{title: t2}
|
||||
|
||||
app.Controller("/", new(testControllerBindStruct), myTitlePtr, myTitleV)
|
||||
app.Controller("/deep", new(testControllerBindDeep), myTitlePtr, myTitleV)
|
||||
|
||||
e := httptest.New(t, app)
|
||||
expected := t1 + t2
|
||||
e.GET("/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(expected)
|
||||
e.GET("/deep").Expect().Status(iris.StatusOK).
|
||||
Body().Equal(expected)
|
||||
}
|
||||
|
||||
type (
|
||||
UserController struct{ mvc.Controller }
|
||||
Profile struct{ mvc.Controller }
|
||||
UserProfilePostController struct{ mvc.Controller }
|
||||
)
|
||||
|
||||
func writeRelatives(c mvc.Controller) {
|
||||
c.Ctx.JSON(context.Map{
|
||||
"RelPath": c.RelPath(),
|
||||
"TmplPath": c.RelTmpl(),
|
||||
})
|
||||
}
|
||||
func (c *UserController) Get() {
|
||||
writeRelatives(c.Controller)
|
||||
}
|
||||
|
||||
func (c *Profile) Get() {
|
||||
writeRelatives(c.Controller)
|
||||
}
|
||||
|
||||
func (c *UserProfilePostController) Get() {
|
||||
writeRelatives(c.Controller)
|
||||
}
|
||||
|
||||
func TestControllerRelPathAndRelTmpl(t *testing.T) {
|
||||
app := iris.New()
|
||||
var tests = map[string]context.Map{
|
||||
// UserController
|
||||
"/user": {"RelPath": "/", "TmplPath": "user/"},
|
||||
"/user/42": {"RelPath": "/42", "TmplPath": "user/"},
|
||||
"/user/me": {"RelPath": "/me", "TmplPath": "user/"},
|
||||
// Profile (without Controller suffix, should work as expected)
|
||||
"/profile": {"RelPath": "/", "TmplPath": "profile/"},
|
||||
"/profile/42": {"RelPath": "/42", "TmplPath": "profile/"},
|
||||
"/profile/me": {"RelPath": "/me", "TmplPath": "profile/"},
|
||||
// UserProfilePost
|
||||
"/user/profile/post": {"RelPath": "/", "TmplPath": "user/profile/post/"},
|
||||
"/user/profile/post/42": {"RelPath": "/42", "TmplPath": "user/profile/post/"},
|
||||
"/user/profile/post/mine": {"RelPath": "/mine", "TmplPath": "user/profile/post/"},
|
||||
}
|
||||
|
||||
app.Controller("/user /user/me /user/{id}",
|
||||
new(UserController))
|
||||
|
||||
app.Controller("/profile /profile/me /profile/{id}",
|
||||
new(Profile))
|
||||
|
||||
app.Controller("/user/profile/post /user/profile/post/mine /user/profile/post/{id}",
|
||||
new(UserProfilePostController))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
for path, tt := range tests {
|
||||
e.GET(path).Expect().Status(iris.StatusOK).JSON().Equal(tt)
|
||||
}
|
||||
}
|
||||
|
||||
type testCtrl0 struct {
|
||||
testCtrl00
|
||||
}
|
||||
|
||||
func (c *testCtrl0) Get() {
|
||||
username := c.Params.Get("username")
|
||||
c.Model = Model{Username: username}
|
||||
}
|
||||
|
||||
func (c *testCtrl0) EndRequest(ctx context.Context) {
|
||||
writeModels(ctx, "myModel")
|
||||
|
||||
if c.TitlePointer == nil {
|
||||
ctx.Writef("\nTitlePointer is nil!\n")
|
||||
} else {
|
||||
ctx.Writef(c.TitlePointer.title)
|
||||
}
|
||||
|
||||
//should be the same as `.testCtrl000.testCtrl0000.EndRequest(ctx)`
|
||||
c.testCtrl00.EndRequest(ctx)
|
||||
}
|
||||
|
||||
type testCtrl00 struct {
|
||||
testCtrl000
|
||||
|
||||
Model Model `iris:"model" name:"myModel"`
|
||||
}
|
||||
|
||||
type testCtrl000 struct {
|
||||
testCtrl0000
|
||||
|
||||
TitlePointer *testBindType
|
||||
}
|
||||
|
||||
type testCtrl0000 struct {
|
||||
mvc.Controller
|
||||
}
|
||||
|
||||
func (c *testCtrl0000) EndRequest(ctx context.Context) {
|
||||
ctx.Writef("finish")
|
||||
}
|
||||
|
||||
func TestControllerInsideControllerRecursively(t *testing.T) {
|
||||
var (
|
||||
username = "gerasimos"
|
||||
title = "mytitle"
|
||||
expected = username + title + "finish"
|
||||
)
|
||||
|
||||
app := iris.New()
|
||||
|
||||
app.Controller("/user/{username}", new(testCtrl0),
|
||||
&testBindType{title: title})
|
||||
|
||||
e := httptest.New(t, app)
|
||||
e.GET("/user/" + username).Expect().
|
||||
Status(iris.StatusOK).Body().Equal(expected)
|
||||
}
|
||||
|
||||
type testControllerRelPathFromFunc struct{ mvc.Controller }
|
||||
|
||||
func (c *testControllerRelPathFromFunc) EndRequest(ctx context.Context) {
|
||||
ctx.Writef("%s:%s", ctx.Method(), ctx.Path())
|
||||
c.Controller.EndRequest(ctx)
|
||||
}
|
||||
|
||||
func (c *testControllerRelPathFromFunc) Get() {}
|
||||
func (c *testControllerRelPathFromFunc) GetBy(int64) {}
|
||||
func (c *testControllerRelPathFromFunc) GetAnythingByWildcard(string) {}
|
||||
|
||||
func (c *testControllerRelPathFromFunc) GetLogin() {}
|
||||
func (c *testControllerRelPathFromFunc) PostLogin() {}
|
||||
|
||||
func (c *testControllerRelPathFromFunc) GetAdminLogin() {}
|
||||
|
||||
func (c *testControllerRelPathFromFunc) PutSomethingIntoThis() {}
|
||||
|
||||
func (c *testControllerRelPathFromFunc) GetSomethingBy(bool) {}
|
||||
func (c *testControllerRelPathFromFunc) GetSomethingByBy(string, int) {}
|
||||
func (c *testControllerRelPathFromFunc) GetSomethingNewBy(string, int) {} // two input arguments, one By which is the latest word.
|
||||
func (c *testControllerRelPathFromFunc) GetSomethingByElseThisBy(bool, int) {} // two input arguments
|
||||
|
||||
func TestControllerRelPathFromFunc(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/", new(testControllerRelPathFromFunc))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
e.GET("/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/")
|
||||
|
||||
e.GET("/42").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/42")
|
||||
e.GET("/something/true").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/something/true")
|
||||
e.GET("/something/false").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/something/false")
|
||||
e.GET("/something/truee").Expect().Status(iris.StatusNotFound)
|
||||
e.GET("/something/falsee").Expect().Status(iris.StatusNotFound)
|
||||
e.GET("/something/kataras/42").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/something/kataras/42")
|
||||
e.GET("/something/new/kataras/42").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/something/new/kataras/42")
|
||||
e.GET("/something/true/else/this/42").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/something/true/else/this/42")
|
||||
|
||||
e.GET("/login").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/login")
|
||||
e.POST("/login").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("POST:/login")
|
||||
e.GET("/admin/login").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/admin/login")
|
||||
e.PUT("/something/into/this").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("PUT:/something/into/this")
|
||||
e.GET("/42").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/42")
|
||||
e.GET("/anything/here").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("GET:/anything/here")
|
||||
}
|
||||
|
||||
type testControllerActivateListener struct {
|
||||
mvc.Controller
|
||||
|
||||
TitlePointer *testBindType
|
||||
}
|
||||
|
||||
func (c *testControllerActivateListener) OnActivate(t *activator.TController) {
|
||||
t.BindValue(&testBindType{
|
||||
title: "default title",
|
||||
})
|
||||
}
|
||||
|
||||
func (c *testControllerActivateListener) Get() {
|
||||
c.Text = c.TitlePointer.title
|
||||
}
|
||||
|
||||
func TestControllerActivateListener(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/", new(testControllerActivateListener))
|
||||
app.Controller("/manual", new(testControllerActivateListener), &testBindType{
|
||||
title: "my title",
|
||||
})
|
||||
|
||||
e := httptest.New(t, app)
|
||||
e.GET("/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("default title")
|
||||
e.GET("/manual").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("my title")
|
||||
}
|
||||
26
mvc/go19.go
26
mvc/go19.go
@@ -1,26 +0,0 @@
|
||||
// +build go1.9
|
||||
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"html/template"
|
||||
|
||||
"github.com/kataras/iris/mvc/activator"
|
||||
)
|
||||
|
||||
type (
|
||||
// HTML wraps the "s" with the template.HTML
|
||||
// in order to be marked as safe content, to be rendered as html and not escaped.
|
||||
HTML = template.HTML
|
||||
|
||||
// TController contains the necessary controller's pre-serve information.
|
||||
//
|
||||
// With `TController` the `Controller` can register custom routes
|
||||
// or modify the provided values that will be binded to the
|
||||
// controller later on.
|
||||
//
|
||||
// Look the `mvc/activator#TController` for its implementation.
|
||||
//
|
||||
// A shortcut for the `mvc/activator#TController`, useful when `OnActivate` is being used.
|
||||
TController = activator.TController
|
||||
)
|
||||
@@ -1,58 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/mvc/activator/methodfunc"
|
||||
)
|
||||
|
||||
// build go1.9 only(go19.go)-->
|
||||
// // Result is a response dispatcher.
|
||||
// // All types that complete this interface
|
||||
// // can be returned as values from the method functions.
|
||||
// Result = methodfunc.Result
|
||||
// <--
|
||||
// No, let's just copy-paste in order to go 1.8 users have this type
|
||||
// easy to be used from the root mvc package,
|
||||
// sometimes duplication doesn't hurt.
|
||||
|
||||
// Result is a response dispatcher.
|
||||
// All types that complete this interface
|
||||
// can be returned as values from the method functions.
|
||||
//
|
||||
// Example at: https://github.com/kataras/iris/tree/master/_examples/mvc/overview.
|
||||
type Result interface { // NOTE: Should be always compatible with the methodfunc.Result.
|
||||
// Dispatch should sends the response to the context's response writer.
|
||||
Dispatch(ctx context.Context)
|
||||
}
|
||||
|
||||
var defaultFailureResponse = Response{Code: methodfunc.DefaultErrStatusCode}
|
||||
|
||||
// Try will check if "fn" ran without any panics,
|
||||
// using recovery,
|
||||
// and return its result as the final response
|
||||
// otherwise it returns the "failure" response if any,
|
||||
// if not then a 400 bad request is being sent.
|
||||
//
|
||||
// Example usage at: https://github.com/kataras/iris/blob/master/mvc/method_result_test.go.
|
||||
func Try(fn func() Result, failure ...Result) Result {
|
||||
var failed bool
|
||||
var actionResponse Result
|
||||
|
||||
func() {
|
||||
defer func() {
|
||||
if rec := recover(); rec != nil {
|
||||
failed = true
|
||||
}
|
||||
}()
|
||||
actionResponse = fn()
|
||||
}()
|
||||
|
||||
if failed {
|
||||
if len(failure) > 0 {
|
||||
return failure[0]
|
||||
}
|
||||
return defaultFailureResponse
|
||||
}
|
||||
|
||||
return actionResponse
|
||||
}
|
||||
@@ -1,69 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/mvc/activator/methodfunc"
|
||||
)
|
||||
|
||||
// Response completes the `methodfunc.Result` interface.
|
||||
// It's being used as an alternative return value which
|
||||
// wraps the status code, the content type, a content as bytes or as string
|
||||
// and an error, it's smart enough to complete the request and send the correct response to the client.
|
||||
type Response struct {
|
||||
Code int
|
||||
ContentType string
|
||||
Content []byte
|
||||
|
||||
// if not empty then content type is the text/plain
|
||||
// and content is the text as []byte.
|
||||
Text string
|
||||
// If not nil then it will fire that as "application/json" or the
|
||||
// "ContentType" if not empty.
|
||||
Object interface{}
|
||||
|
||||
// If Path is not empty then it will redirect
|
||||
// the client to this Path, if Code is >= 300 and < 400
|
||||
// then it will use that Code to do the redirection, otherwise
|
||||
// StatusFound(302) or StatusSeeOther(303) for post methods will be used.
|
||||
// Except when err != nil.
|
||||
Path string
|
||||
|
||||
// if not empty then fire a 400 bad request error
|
||||
// unless the Status is > 200, then fire that error code
|
||||
// with the Err.Error() string as its content.
|
||||
//
|
||||
// if Err.Error() is empty then it fires the custom error handler
|
||||
// if any otherwise the framework sends the default http error text based on the status.
|
||||
Err error
|
||||
Try func() int
|
||||
|
||||
// if true then it skips everything else and it throws a 404 not found error.
|
||||
// Can be named as Failure but NotFound is more precise name in order
|
||||
// to be visible that it's different than the `Err`
|
||||
// because it throws a 404 not found instead of a 400 bad request.
|
||||
// NotFound bool
|
||||
// let's don't add this yet, it has its dangerous of missuse.
|
||||
}
|
||||
|
||||
var _ methodfunc.Result = Response{}
|
||||
|
||||
// Dispatch writes the response result to the context's response writer.
|
||||
func (r Response) Dispatch(ctx context.Context) {
|
||||
if r.Path != "" && r.Err == nil {
|
||||
// it's not a redirect valid status
|
||||
if r.Code < 300 || r.Code >= 400 {
|
||||
if ctx.Method() == "POST" {
|
||||
r.Code = 303 // StatusSeeOther
|
||||
}
|
||||
r.Code = 302 // StatusFound
|
||||
}
|
||||
ctx.Redirect(r.Path, r.Code)
|
||||
return
|
||||
}
|
||||
|
||||
if s := r.Text; s != "" {
|
||||
r.Content = []byte(s)
|
||||
}
|
||||
|
||||
methodfunc.DispatchCommon(ctx, r.Code, r.ContentType, r.Content, r.Object, r.Err, true)
|
||||
}
|
||||
@@ -1,271 +0,0 @@
|
||||
package mvc_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"github.com/kataras/iris"
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/httptest"
|
||||
"github.com/kataras/iris/mvc"
|
||||
)
|
||||
|
||||
// activator/methodfunc/func_caller.go.
|
||||
// and activator/methodfunc/func_result_dispatcher.go
|
||||
|
||||
type testControllerMethodResult struct {
|
||||
mvc.C
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResult) Get() mvc.Result {
|
||||
return mvc.Response{
|
||||
Text: "Hello World!",
|
||||
}
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResult) GetWithStatus() mvc.Response { // or mvc.Result again, no problem.
|
||||
return mvc.Response{
|
||||
Text: "This page doesn't exist",
|
||||
Code: iris.StatusNotFound,
|
||||
}
|
||||
}
|
||||
|
||||
type testCustomStruct struct {
|
||||
Name string `json:"name" xml:"name"`
|
||||
Age int `json:"age" xml:"age"`
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResult) GetJson() mvc.Result {
|
||||
var err error
|
||||
if c.Ctx.URLParamExists("err") {
|
||||
err = errors.New("error here")
|
||||
}
|
||||
return mvc.Response{
|
||||
Err: err, // if err != nil then it will fire the error's text with a BadRequest.
|
||||
Object: testCustomStruct{Name: "Iris", Age: 2},
|
||||
}
|
||||
}
|
||||
|
||||
var things = []string{"thing 0", "thing 1", "thing 2"}
|
||||
|
||||
func (c *testControllerMethodResult) GetThingWithTryBy(index int) mvc.Result {
|
||||
failure := mvc.Response{
|
||||
Text: "thing does not exist",
|
||||
Code: iris.StatusNotFound,
|
||||
}
|
||||
|
||||
return mvc.Try(func() mvc.Result {
|
||||
// if panic because of index exceed the slice
|
||||
// then the "failure" response will be returned instead.
|
||||
return mvc.Response{Text: things[index]}
|
||||
}, failure)
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResult) GetThingWithTryDefaultBy(index int) mvc.Result {
|
||||
return mvc.Try(func() mvc.Result {
|
||||
// if panic because of index exceed the slice
|
||||
// then the default failure response will be returned instead (400 bad request).
|
||||
return mvc.Response{Text: things[index]}
|
||||
})
|
||||
}
|
||||
|
||||
func TestControllerMethodResult(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/", new(testControllerMethodResult))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
|
||||
e.GET("/").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("Hello World!")
|
||||
|
||||
e.GET("/with/status").Expect().Status(iris.StatusNotFound).
|
||||
Body().Equal("This page doesn't exist")
|
||||
|
||||
e.GET("/json").Expect().Status(iris.StatusOK).
|
||||
JSON().Equal(iris.Map{
|
||||
"name": "Iris",
|
||||
"age": 2,
|
||||
})
|
||||
|
||||
e.GET("/json").WithQuery("err", true).Expect().
|
||||
Status(iris.StatusBadRequest).
|
||||
Body().Equal("error here")
|
||||
|
||||
e.GET("/thing/with/try/1").Expect().
|
||||
Status(iris.StatusOK).
|
||||
Body().Equal("thing 1")
|
||||
// failure because of index exceed the slice
|
||||
e.GET("/thing/with/try/3").Expect().
|
||||
Status(iris.StatusNotFound).
|
||||
Body().Equal("thing does not exist")
|
||||
|
||||
e.GET("/thing/with/try/default/3").Expect().
|
||||
Status(iris.StatusBadRequest).
|
||||
Body().Equal("Bad Request")
|
||||
}
|
||||
|
||||
type testControllerMethodResultTypes struct {
|
||||
mvc.Controller
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetText() string {
|
||||
return "text"
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetStatus() int {
|
||||
return iris.StatusBadGateway
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetTextWithStatusOk() (string, int) {
|
||||
return "OK", iris.StatusOK
|
||||
}
|
||||
|
||||
// tests should have output arguments mixed
|
||||
func (c *testControllerMethodResultTypes) GetStatusWithTextNotOkBy(first string, second string) (int, string) {
|
||||
return iris.StatusForbidden, "NOT_OK_" + first + second
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetTextAndContentType() (string, string) {
|
||||
return "<b>text</b>", "text/html"
|
||||
}
|
||||
|
||||
type testControllerMethodCustomResult struct {
|
||||
HTML string
|
||||
}
|
||||
|
||||
// The only one required function to make that a custom Response dispatcher.
|
||||
func (r testControllerMethodCustomResult) Dispatch(ctx context.Context) {
|
||||
ctx.HTML(r.HTML)
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomResponse() testControllerMethodCustomResult {
|
||||
return testControllerMethodCustomResult{"<b>text</b>"}
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomResponseWithStatusOk() (testControllerMethodCustomResult, int) {
|
||||
return testControllerMethodCustomResult{"<b>OK</b>"}, iris.StatusOK
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomResponseWithStatusNotOk() (testControllerMethodCustomResult, int) {
|
||||
return testControllerMethodCustomResult{"<b>internal server error</b>"}, iris.StatusInternalServerError
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomStruct() testCustomStruct {
|
||||
return testCustomStruct{"Iris", 2}
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomStructWithStatusNotOk() (testCustomStruct, int) {
|
||||
return testCustomStruct{"Iris", 2}, iris.StatusInternalServerError
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomStructWithContentType() (testCustomStruct, string) {
|
||||
return testCustomStruct{"Iris", 2}, "text/xml"
|
||||
}
|
||||
|
||||
func (c *testControllerMethodResultTypes) GetCustomStructWithError() (s testCustomStruct, err error) {
|
||||
s = testCustomStruct{"Iris", 2}
|
||||
if c.Ctx.URLParamExists("err") {
|
||||
err = errors.New("omit return of testCustomStruct and fire error")
|
||||
}
|
||||
|
||||
// it should send the testCustomStruct as JSON if error is nil
|
||||
// otherwise it should fire the default error(BadRequest) with the error's text.
|
||||
return
|
||||
}
|
||||
|
||||
func TestControllerMethodResultTypes(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/", new(testControllerMethodResultTypes))
|
||||
|
||||
e := httptest.New(t, app)
|
||||
|
||||
e.GET("/text").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("text")
|
||||
|
||||
e.GET("/status").Expect().Status(iris.StatusBadGateway)
|
||||
|
||||
e.GET("/text/with/status/ok").Expect().Status(iris.StatusOK).
|
||||
Body().Equal("OK")
|
||||
|
||||
e.GET("/status/with/text/not/ok/first/second").Expect().Status(iris.StatusForbidden).
|
||||
Body().Equal("NOT_OK_firstsecond")
|
||||
|
||||
e.GET("/text/and/content/type").Expect().Status(iris.StatusOK).
|
||||
ContentType("text/html", "utf-8").
|
||||
Body().Equal("<b>text</b>")
|
||||
|
||||
e.GET("/custom/response").Expect().Status(iris.StatusOK).
|
||||
ContentType("text/html", "utf-8").
|
||||
Body().Equal("<b>text</b>")
|
||||
e.GET("/custom/response/with/status/ok").Expect().Status(iris.StatusOK).
|
||||
ContentType("text/html", "utf-8").
|
||||
Body().Equal("<b>OK</b>")
|
||||
e.GET("/custom/response/with/status/not/ok").Expect().Status(iris.StatusInternalServerError).
|
||||
ContentType("text/html", "utf-8").
|
||||
Body().Equal("<b>internal server error</b>")
|
||||
|
||||
expectedResultFromCustomStruct := map[string]interface{}{
|
||||
"name": "Iris",
|
||||
"age": 2,
|
||||
}
|
||||
e.GET("/custom/struct").Expect().Status(iris.StatusOK).
|
||||
JSON().Equal(expectedResultFromCustomStruct)
|
||||
e.GET("/custom/struct/with/status/not/ok").Expect().Status(iris.StatusInternalServerError).
|
||||
JSON().Equal(expectedResultFromCustomStruct)
|
||||
e.GET("/custom/struct/with/content/type").Expect().Status(iris.StatusOK).
|
||||
ContentType("text/xml", "utf-8")
|
||||
e.GET("/custom/struct/with/error").Expect().Status(iris.StatusOK).
|
||||
JSON().Equal(expectedResultFromCustomStruct)
|
||||
e.GET("/custom/struct/with/error").WithQuery("err", true).Expect().
|
||||
Status(iris.StatusBadRequest). // the default status code if error is not nil
|
||||
// the content should be not JSON it should be the status code's text
|
||||
// it will fire the error's text
|
||||
Body().Equal("omit return of testCustomStruct and fire error")
|
||||
}
|
||||
|
||||
type testControllerViewResultRespectCtxViewData struct {
|
||||
T *testing.T
|
||||
mvc.C
|
||||
}
|
||||
|
||||
func (t *testControllerViewResultRespectCtxViewData) BeginRequest(ctx context.Context) {
|
||||
t.C.BeginRequest(ctx)
|
||||
ctx.ViewData("name_begin", "iris_begin")
|
||||
}
|
||||
|
||||
func (t *testControllerViewResultRespectCtxViewData) EndRequest(ctx context.Context) {
|
||||
t.C.EndRequest(ctx)
|
||||
// check if data is not overridden by return mvc.View {Data: context.Map...}
|
||||
|
||||
dataWritten := ctx.GetViewData()
|
||||
if dataWritten == nil {
|
||||
t.T.Fatalf("view data is nil, both BeginRequest and Get failed to write the data")
|
||||
return
|
||||
}
|
||||
|
||||
if dataWritten["name_begin"] == nil {
|
||||
t.T.Fatalf(`view data[name_begin] is nil,
|
||||
BeginRequest's ctx.ViewData call have been overridden by Get's return mvc.View {Data: }.
|
||||
Total view data: %v`, dataWritten)
|
||||
}
|
||||
|
||||
if dataWritten["name"] == nil {
|
||||
t.T.Fatalf("view data[name] is nil, Get's return mvc.View {Data: } didn't work. Total view data: %v", dataWritten)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *testControllerViewResultRespectCtxViewData) Get() mvc.Result {
|
||||
return mvc.View{
|
||||
Name: "doesnt_exists.html",
|
||||
Data: context.Map{"name": "iris"}, // we care about this only.
|
||||
Code: iris.StatusInternalServerError,
|
||||
}
|
||||
}
|
||||
|
||||
func TestControllerViewResultRespectCtxViewData(t *testing.T) {
|
||||
app := iris.New()
|
||||
app.Controller("/", new(testControllerViewResultRespectCtxViewData), t)
|
||||
e := httptest.New(t, app)
|
||||
|
||||
e.GET("/").Expect().Status(iris.StatusInternalServerError)
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/mvc/activator/methodfunc"
|
||||
|
||||
"github.com/fatih/structs"
|
||||
)
|
||||
|
||||
// View completes the `methodfunc.Result` interface.
|
||||
// It's being used as an alternative return value which
|
||||
// wraps the template file name, layout, (any) view data, status code and error.
|
||||
// It's smart enough to complete the request and send the correct response to the client.
|
||||
//
|
||||
// Example at: https://github.com/kataras/iris/blob/master/_examples/mvc/overview/web/controllers/hello_controller.go.
|
||||
type View struct {
|
||||
Name string
|
||||
Layout string
|
||||
Data interface{} // map or a custom struct.
|
||||
Code int
|
||||
Err error
|
||||
}
|
||||
|
||||
var _ methodfunc.Result = View{}
|
||||
|
||||
const dotB = byte('.')
|
||||
|
||||
// DefaultViewExt is the default extension if `view.Name `is missing,
|
||||
// but note that it doesn't care about
|
||||
// the app.RegisterView(iris.$VIEW_ENGINE("./$dir", "$ext"))'s $ext.
|
||||
// so if you don't use the ".html" as extension for your files
|
||||
// you have to append the extension manually into the `view.Name`
|
||||
// or change this global variable.
|
||||
var DefaultViewExt = ".html"
|
||||
|
||||
func ensureExt(s string) string {
|
||||
if len(s) == 0 {
|
||||
return "index" + DefaultViewExt
|
||||
}
|
||||
|
||||
if strings.IndexByte(s, dotB) < 1 {
|
||||
s += DefaultViewExt
|
||||
}
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
// Dispatch writes the template filename, template layout and (any) data to the client.
|
||||
// Completes the `Result` interface.
|
||||
func (r View) Dispatch(ctx context.Context) { // r as Response view.
|
||||
if r.Err != nil {
|
||||
if r.Code < 400 {
|
||||
r.Code = methodfunc.DefaultErrStatusCode
|
||||
}
|
||||
ctx.StatusCode(r.Code)
|
||||
ctx.WriteString(r.Err.Error())
|
||||
ctx.StopExecution()
|
||||
return
|
||||
}
|
||||
|
||||
if r.Code > 0 {
|
||||
ctx.StatusCode(r.Code)
|
||||
}
|
||||
|
||||
if r.Name != "" {
|
||||
r.Name = ensureExt(r.Name)
|
||||
|
||||
if r.Layout != "" {
|
||||
r.Layout = ensureExt(r.Layout)
|
||||
ctx.ViewLayout(r.Layout)
|
||||
}
|
||||
|
||||
if r.Data != nil {
|
||||
// In order to respect any c.Ctx.ViewData that may called manually before;
|
||||
dataKey := ctx.Application().ConfigurationReadOnly().GetViewDataContextKey()
|
||||
if ctx.Values().Get(dataKey) == nil {
|
||||
// if no c.Ctx.ViewData then it's empty do a
|
||||
// pure set, it's faster.
|
||||
ctx.Values().Set(dataKey, r.Data)
|
||||
} else {
|
||||
// else check if r.Data is map or struct, if struct convert it to map,
|
||||
// do a range loop and set the data one by one.
|
||||
// context.Map is actually a map[string]interface{} but we have to make that check;
|
||||
if m, ok := r.Data.(map[string]interface{}); ok {
|
||||
setViewData(ctx, m)
|
||||
} else if m, ok := r.Data.(context.Map); ok {
|
||||
setViewData(ctx, m)
|
||||
} else if structs.IsStruct(r.Data) {
|
||||
setViewData(ctx, structs.Map(r))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ctx.View(r.Name)
|
||||
}
|
||||
}
|
||||
|
||||
func setViewData(ctx context.Context, data map[string]interface{}) {
|
||||
for k, v := range data {
|
||||
ctx.ViewData(k, v)
|
||||
}
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"github.com/kataras/iris/context"
|
||||
"github.com/kataras/iris/mvc/activator"
|
||||
"github.com/kataras/iris/sessions"
|
||||
|
||||
"github.com/kataras/golog"
|
||||
)
|
||||
|
||||
var defaultManager = sessions.New(sessions.Config{})
|
||||
|
||||
// SessionController is a simple `Controller` implementation
|
||||
// which requires a binded session manager in order to give
|
||||
// direct access to the current client's session via its `Session` field.
|
||||
type SessionController struct {
|
||||
C
|
||||
|
||||
Manager *sessions.Sessions
|
||||
Session *sessions.Session
|
||||
}
|
||||
|
||||
// OnActivate called, once per application lifecycle NOT request,
|
||||
// every single time the dev registers a specific SessionController-based controller.
|
||||
// It makes sure that its "Manager" field is filled
|
||||
// even if the caller didn't provide any sessions manager via the `app.Controller` function.
|
||||
func (s *SessionController) OnActivate(t *activator.TController) {
|
||||
if !t.BindValueTypeExists(defaultManager) {
|
||||
t.BindValue(defaultManager)
|
||||
golog.Warnf(`MVC SessionController: couldn't find any "*sessions.Sessions" bindable value to fill the "Manager" field,
|
||||
therefore this controller is using the default sessions manager instead.
|
||||
Please refer to the documentation to learn how you can provide the session manager`)
|
||||
}
|
||||
}
|
||||
|
||||
// BeginRequest calls the Controller's BeginRequest
|
||||
// and tries to initialize the current user's Session.
|
||||
func (s *SessionController) BeginRequest(ctx context.Context) {
|
||||
s.C.BeginRequest(ctx)
|
||||
if s.Manager == nil {
|
||||
ctx.Application().Logger().Errorf(`MVC SessionController: sessions manager is nil, report this as a bug
|
||||
because the SessionController should predict this on its activation state and use a default one automatically`)
|
||||
return
|
||||
}
|
||||
|
||||
s.Session = s.Manager.Start(ctx)
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
func findCtrlWords(ctrlName string) (w []string) {
|
||||
end := len(ctrlName)
|
||||
start := -1
|
||||
for i, n := 0, end; i < n; i++ {
|
||||
c := rune(ctrlName[i])
|
||||
if unicode.IsUpper(c) {
|
||||
// it doesn't count the last uppercase
|
||||
if start != -1 {
|
||||
end = i
|
||||
w = append(w, strings.ToLower(ctrlName[start:end]))
|
||||
}
|
||||
start = i
|
||||
continue
|
||||
}
|
||||
end = i + 1
|
||||
|
||||
}
|
||||
|
||||
// We can't omit the last name, we have to take it.
|
||||
// because of controller names like
|
||||
// "UserProfile", we need to return "user", "profile"
|
||||
// if "UserController", we need to return "user"
|
||||
// if "User", we need to return "user".
|
||||
last := ctrlName[start:end]
|
||||
if last == ctrlSuffix {
|
||||
return
|
||||
}
|
||||
|
||||
w = append(w, strings.ToLower(last))
|
||||
return
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package mvc
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestFindCtrlWords(t *testing.T) {
|
||||
var tests = map[string][]string{
|
||||
"UserController": {"user"},
|
||||
"UserPostController": {"user", "post"},
|
||||
"ProfileController": {"profile"},
|
||||
"UserProfileController": {"user", "profile"},
|
||||
"UserProfilePostController": {"user", "profile", "post"},
|
||||
"UserProfile": {"user", "profile"},
|
||||
"Profile": {"profile"},
|
||||
"User": {"user"},
|
||||
}
|
||||
|
||||
for ctrlName, expected := range tests {
|
||||
words := findCtrlWords(ctrlName)
|
||||
if len(expected) != len(words) {
|
||||
t.Fatalf("expected words and return don't have the same length: [%d] != [%d] | '%s' != '%s'",
|
||||
len(expected), len(words), expected, words)
|
||||
}
|
||||
for i, w := range words {
|
||||
if expected[i] != w {
|
||||
t.Fatalf("expected word is not equal with the return one: '%s' != '%s'", expected[i], w)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user