示例#1
0
文件: top.go 项目: Laller/nocrud
func (t *Top) route() (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf(fmt.Sprint(r) + string(debug.Stack()))
		}
	}()
	ctx := t.ctx
	odoc := ctx.Options().Document()
	nouns := scut.GetNouns(odoc)
	np := ctx.NonPortable()
	hl, err := highlev.New(ctx.Conducting().Hooks(), np.Resource(), nouns, np.Params())
	if err != nil {
		display.New(ctx).Do(nil)
		return nil
	}
	deflev_i, _ := odoc.Get("default_level")
	deflev, _ := numcon.Int(deflev_i)
	ret, err := hl.Run(ctx.Db(), ctx.User(), deflev)
	if err != nil {
		return err
	}
	if ctx.NonPortable().View() {
		ctx.ViewContext().Publish("main_noun", hl.Noun())
		files := []string{
			hl.Noun() + "/" + hl.Verb(),
			hl.VerbLocation() + "/" + hl.Verb(),
		}
		return t.Get(ret, files)
	} else {
		return t.Post(ret, hl.Verb())
	}
	return nil
}
示例#2
0
文件: evenday.go 项目: crufter/nocrud
// Handles both Minute and date inputs
func GenericToInterval(fromI, toI interface{}) (*Interval, error) {
	from, err := numcon.Int(fromI)
	if err != nil {
		return nil, err
	}
	to, err := numcon.Int(toI)
	if err != nil {
		return nil, err
	}
	if from > 1440 {
		from = int(DateToMinute(int64(from))) // Ouch...
	}
	if to > 1440 {
		to = int(DateToMinute(int64(to)))
	}
	interval, err := NewInterval(Minute(from), Minute(to))
	if err != nil {
		return nil, err
	}
	return interval, nil
}
示例#3
0
// Immediately terminate the run of the action in case the user level is lower than the required level of the given action.
// By default, if not otherwise specified, every action requires a level of 300 (admin rights).
//
// Made public to be able to call separately from PuzzlesSolved.
// This way one can implement moderation.
func UserAllowed(uni *context.Uni, auth_options map[string]interface{}) error {
	minlev := 300
	lev_in_opt := auth_options["min_lev"]
	num, err := numcon.Int(lev_in_opt)
	if err == nil {
		minlev = num
	}
	if scut.Ulev(uni.Dat["_user"]) < minlev {
		return fmt.Errorf("You have no rights to do that.")
	}
	return nil
}
示例#4
0
文件: builtins.go 项目: Laller/nocrud
func getList(ctx iface.Context, noun string, params ...interface{}) []interface{} {
	nouns, ok := ctx.Options().Document().GetM("nouns")
	if !ok {
		panic("Can't find nouns.")
	}
	inp := convert.ListToMap(params...)
	hl, err := highlev.New(ctx.Conducting().Hooks(), "/"+noun, nouns, inp)
	if err != nil {
		panic(err)
	}
	deflev_i, _ := ctx.Options().Document().Get("default_level")
	deflev, _ := numcon.Int(deflev_i)
	ret, err := hl.Run(ctx.Db(), ctx.User(), deflev)
	if err != nil {
		panic(err)
	}
	return ret
}
示例#5
0
文件: highlev.go 项目: Laller/nocrud
func (h *HighLev) Run(db iface.Db, usr iface.User, defminlev int) ([]interface{}, error) {
	desc := h.desc
	levi, ok := jsonp.Get(h.nouns, fmt.Sprintf("%v.verbs.%v.level", desc.Sentence.Noun, desc.Sentence.Verb))
	if !ok {
		levi = defminlev
	}
	lev, _ := numcon.Int(levi)
	if usr.Level() < lev {
		return nil, fmt.Errorf("Not allowed.")
	}
	filterCreator := func(c string, input map[string]interface{}) (iface.Filter, error) {
		return db.NewFilter(c, input)
	}
	inp, data, err := desc.CreateInputs(filterCreator)
	if err != nil {
		return nil, err
	}
	if data != nil {
		if desc.Sentence.Noun != "options" {
			data, err = h.validate(desc.Sentence.Noun, desc.Sentence.Verb, data)
			if err != nil {
				return nil, err
			}
		}
		inp = append(inp, data)
	}
	module := h.hooks.Module(desc.VerbLocation)
	if !module.Exists() {
		return nil, fmt.Errorf("Unkown module.")
	}
	ins := module.Instance()
	var ret []interface{}
	ret_rec := func(i ...interface{}) {
		ret = i
	}
	err = ins.Method(desc.Sentence.Verb).Call(ret_rec, inp...)
	if err != nil {
		return nil, err
	}
	return ret, nil
}
示例#6
0
文件: top.go 项目: Laller/nocrud
func (t *Top) routeWS() (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf(fmt.Sprint(r) + string(debug.Stack()))
		}
	}()
	ctx := t.ctx
	odoc := ctx.Options().Document()
	nouns, ok := odoc.GetM("nouns")
	if !ok {
		return fmt.Errorf("No nouns, cant route websocket.")
	}
	np := ctx.NonPortable()
	hl, err := highlev.New(ctx.Conducting().Hooks(), np.Resource(), nouns, np.Params())
	if err != nil {
		return err
	}
	deflev_i, _ := odoc.Get("default_level")
	deflev, _ := numcon.Int(deflev_i)
	_, err = hl.Run(ctx.Db(), ctx.User(), deflev)
	return err
}
示例#7
0
// Works from Get or GetSingle only.
func getSub(ctx iface.Context, noun string, params ...interface{}) []interface{} {
	nouns, ok := ctx.Options().Document().GetM("nouns")
	if !ok {
		panic("Can't find nouns.")
	}
	np := ctx.NonPortable()
	hl, err := highlev.New(ctx.Conducting().Hooks(), np.Resource(), nouns, np.Params())
	if err != nil {
		panic(err)
	}
	inp := convert.ListToMap(params...)
	subhl, err := hl.Sub(noun, inp)
	if err != nil {
		panic(err)
	}
	deflev_i, _ := ctx.Options().Document().Get("defaultLevel")
	deflev, _ := numcon.Int(deflev_i)
	ret, err := subhl.Run(ctx.Db(), ctx.User(), deflev)
	if err != nil {
		panic(err)
	}
	return ret
}
示例#8
0
func toScheme(a interface{}) (Scheme, error) {
	empty := Scheme{}
	s := Scheme{}
	s.Specific = map[string]interface{}{}
	ai, err := numcon.Int(a)
	if err == nil && ai == 1 {
		s.Type = "string"
		return s, nil
	}
	am, ok := a.(map[string]interface{})
	if !ok {
		return empty, fmt.Errorf("Can't interpret scheme.")
	}
	s.SliceMin = -1 // 0 is not good as a default value since it can be a legal one too.
	s.SliceMax = -1
	for i, v := range am {
		switch i {
		case "must":
			s.Must, ok = v.(bool)
			if !ok {
				return empty, fmt.Errorf("Bad scheme: must should be a slice.")
			}
		case "type":
			s.Type, ok = v.(string)
			if !ok {
				return empty, fmt.Errorf("Bad scheme: type should be a string.")
			}
		case "slice":
			s.Slice, ok = v.(bool)
			if !ok {
				return empty, fmt.Errorf("Bad scheme: slice should be a bool.")
			}
		case "sliceMin":
			s.SliceMin, err = numcon.Int(v)
			if err != nil {
				return empty, fmt.Errorf("Bad scheme: sliceMin should be int compatible.")
			}
		case "sliceMax":
			s.SliceMax, err = numcon.Int(v)
			if err != nil {
				return empty, fmt.Errorf("Bad scheme: sliceMax should be int compatible.")
			}
		case "allOrNothing":
			s.AllOrNothing, ok = v.(bool)
			if !ok {
				return empty, fmt.Errorf("Bad scheme: allOrNothing should be a bool.")
			}
		case "min":
			s.Min, err = numcon.Int64(v)
			if err != nil {
				return empty, fmt.Errorf("Bad scheme: min should be int64 compatible.")
			}
		case "max":
			s.Max, err = numcon.Int64(v)
			if err != nil {
				return empty, fmt.Errorf("Bad scheme: max should be int64 compatible.")
			}
		case "regexp":
			s.Regexp, ok = v.(string)
			if !ok {
				return empty, fmt.Errorf("Bad scheme: regexp should be a string.")
			}
		case "ignore":
			s.Ignore, ok = v.(bool)
			if !ok {
				return empty, fmt.Errorf("Bad scheme: ignore should be a string.")
			}
		default:
			s.Specific[i] = v
		}
	}
	return s, nil
}
示例#9
0
文件: highlev.go 项目: crufter/nocrud
func (h *HighLev) Run(db iface.Db, usr iface.User, defminlev int) ([]interface{}, error) {
	desc := h.desc
	// Authentication.
	levi, ok := jsonp.Get(h.nouns, fmt.Sprintf("%v.verbs.%v.level", desc.Sentence.Noun, desc.Sentence.Verb))
	if !ok {
		levi = defminlev
	}
	lev, _ := numcon.Int(levi)
	if usr.Level() < lev {
		return nil, fmt.Errorf("Not allowed.")
	}
	err := h.userChecks(usr)
	if err != nil {
		return nil, err
	}
	filterCreator := func(c string, input map[string]interface{}) (iface.Filter, error) {
		return db.NewFilter(c, input)
	}
	inp, data, err := desc.CreateInputs(filterCreator)
	if err != nil {
		return nil, err
	}
	ownLev, own := h.ownLev()
	if len(inp) > 0 {
		if f, ok := inp[0].(iface.Filter); ok {
			// This hook allows you to modify a filter before a verb accesses it.
			h.hooks.Select("TopModFilter").Fire(f)
			h.hooks.Select(f.Subject() + "TopModFilter").Fire(f)
		}
		if own && lev <= ownLev {
			if f, ok := inp[0].(iface.Filter); ok {
				f.AddQuery(map[string]interface{}{
					"createdBy": usr.Id(),
				})
			}
		}
	}
	if data != nil {
		if desc.Sentence.Noun != "options" {
			data, err = h.validate(desc.Sentence.Noun, desc.Sentence.Verb, data)
			if err != nil {
				return nil, err
			}
		}
		inp = append(inp, data)
	}
	module := h.hooks.Module(desc.VerbLocation)
	if !module.Exists() {
		return nil, fmt.Errorf("Unkown module.")
	}
	ins := module.Instance()
	var ret []interface{}
	ret_rec := func(i ...interface{}) {
		ret = i
	}
	err = ins.Method(desc.Sentence.Verb).Call(ret_rec, inp...)
	if err != nil {
		return nil, err
	}
	return ret, nil
}
示例#10
0
文件: top.go 项目: Laller/chill
func (t *Top) route() error {
	uni := t.uni
	paths := strings.Split(uni.Path, "/")
	if t.config.ServeFiles && strings.Index(paths[len(paths)-1], ".") != -1 {
		t.serveFile()
		return nil
	}
	t.buildUser()
	var ret []interface{}
	ret_rec := func(i ...interface{}) {
		ret = i
	}
	nouns, ok := uni.Opt["nouns"].(map[string]interface{})
	if !ok {
		nouns = map[string]interface{}{
			"options": opt_def,
		}
	}
	if _, ok := nouns["options"]; !ok {
		nouns["options"] = opt_def
	}
	uni.FilterCreator = func(c string, input map[string]interface{}) iface.Filter {
		return filterCreator(uni.Db, uni.Ev, nouns, input, c)
	}
	desc, err := glue.Identify(uni.Path, nouns, convert.Mapify(uni.Req.Form))
	if err != nil {
		display.D(uni)
		return nil
	}
	default_level, _ := numcon.Int(uni.Opt["default_level"])
	levi, ok := jsonp.Get(uni.Opt, fmt.Sprintf("nouns.%v.verbs.%v.level", desc.Sentence.Noun, desc.Sentence.Verb))
	if !ok {
		levi = default_level
	}
	lev, _ := numcon.Int(levi)
	if scut.Ulev(uni.Dat["_user"]) < lev {
		return fmt.Errorf("Not allowed.")
	}
	inp, data, err := desc.CreateInputs(uni.FilterCreator)
	if err != nil {
		return err
	}
	if data != nil {
		if desc.Sentence.Noun != "options" {
			data, err = t.validate(desc.Sentence.Noun, desc.Sentence.Verb, data)
			if err != nil {
				return err
			}
		}
		inp = append(inp, data)
	}
	uni.Route = desc.Route
	uni.Sentence = desc.Sentence
	module := t.uni.NewModule(desc.VerbLocation)
	if !module.Exists() {
		return fmt.Errorf("Unkown module.")
	}
	ins := module.Instance()
	ins.Method(uni.Sentence.Verb).Call(ret_rec, inp...)
	if uni.Req.Method == "GET" {
		uni.Dat["main_noun"] = desc.Sentence.Noun
		uni.Dat["_points"] = []string{desc.Sentence.Noun + "/" + desc.Sentence.Verb, desc.VerbLocation + "/" + desc.Sentence.Verb}
		t.Get(ret)
	} else {
		t.Post(ret)
	}
	return nil
}