Beispiel #1
0
func decodeParams(myroute *Route, rw http.ResponseWriter, r *http.Request) interface{} {
	if myroute.Params == nil {
		return nil
	}

	// get form parameters
	err := r.ParseForm()
	if err != nil {
		fmt.Println("ParseForm err: ", err)
		return nil
	}

	// get mux parameters
	muxvars := mux.Vars(r)

	v := reflect.New(myroute.Params)
	params := v.Interface()

	// set all defaults
	sanitizer.DefaultStruct(params)

	st := reflect.TypeOf(params).Elem()
	vt := reflect.ValueOf(params).Elem()

	for i := 0; i < st.NumField(); i++ {
		field := st.Field(i)
		value := vt.Field(i)

		paramval := ""
		if val, ok := muxvars[strings.ToLower(field.Name)]; ok {
			paramval = val
		} else {
			paramval = r.FormValue(strings.ToLower(field.Name))
		}

		switch field.Type.Kind() {
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			def, _ := strconv.ParseInt(paramval, 10, 64)
			value.SetInt(def)
		case reflect.Float32, reflect.Float64:
			def, _ := strconv.ParseFloat(paramval, 64)
			value.SetFloat(def)
		case reflect.Bool:
			def, _ := strconv.ParseBool(paramval)
			value.SetBool(def)
		case reflect.String:
			value.SetString(paramval)
		default:
			log.Println("decodeParams on type", field.Type.Name(), "not implemented")
		}
	}

	return params
}
Beispiel #2
0
func decodeContent(myroute *Route, rw http.ResponseWriter, r *http.Request, s *session.Session) interface{} {
	if myroute.Json == nil {
		return nil
	}

	// decode json from request
	//fmt.Println("Json : ", myroute.Json)
	v := reflect.New(myroute.Json)
	o := v.Interface()

	// set to default the new structure
	sanitizer.DefaultStruct(o)

	// Check if multipart
	mt, params, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
		log.Println("error parsing header:", err)
	}
	if strings.HasPrefix(mt, "multipart/") {
		log.Println(" = MULTIPART POST = ")
		mr := multipart.NewReader(r.Body, params["boundary"])
		// For each part
		for {
			p, err := mr.NextPart()
			if err == io.EOF {
				// EOF we can stop here
				return o
			}
			if err != nil {
				log.Println("error getting part of multipart form", err)
				return nil
			}
			j, err := ioutil.ReadAll(p)
			if err != nil {
				log.Println("error: unable to get content of the file")
			}
			//log.Println(" => part ... ", string(j))
			// Is it a file ?
			if p.FileName() != "" {
				// Check if target interface has a FileName field
				ta := reflect.Indirect(reflect.ValueOf(o)).FieldByName("File")
				if !ta.IsValid() {
					log.Println("error: target interface does not have File field")
					return nil
				}
				// Check if target interface "File" field is type of routes.File
				if ta.Type() != reflect.TypeOf(&File{}) {
					log.Println("error: target interface field \"File\" is not of type routes.File")
					return nil
				}
				// Assign file to structure
				fs := reflect.New(reflect.TypeOf(File{}))
				fsi := fs.Interface()
				ee := reflect.Indirect(reflect.ValueOf(fsi))
				ee.FieldByName("Name").SetString(p.FileName())
				//ee.FieldByName("Content").SetString(string(j[:]))
				ee.FieldByName("Content").SetBytes(j)
				ta.Set(fs)
			} else {
				// Unmarshall datas into structure
				json.Unmarshal(j, o)
			}
		}
	} else {
		//log.Println(" = normal POST = ")
		decoder := json.NewDecoder(r.Body)
		//fmt.Printf("t : %t\n", o)
		//fmt.Println("o : ", o)
		err := decoder.Decode(o)
		if err != nil {
			log.Panicln("decode failed", err)
		}
		return o
	}
}