Golang JSONMap.GetString方法代码示例

//
// { "verb": "getCoincount", "name": fb-name }
// { "result": true, "answer" : 6357] }
// { "result": false, "answer" : "not a registered user"] }
//
func validateGetCoinCountRequest(req *jsondata.JSONMap) Request {
	name, r1 := req.GetString("name")

	json := "{\"result\": false, \"answer\": \"missing or invalid arguments in getPendingCoinRequests request\"}"
	if !r1 || len(name) < 6 {
		return &BadRequest{json}
	}
	return datastore.NewGetCoinCount(name)
}

func validateGetAchievements(req *jsondata.JSONMap) Request {
	hash, r1 := req.GetString("hash")

	json := "{\"result\": false, \"answer\": \"missing or invalid arguments in getAchievements request\"}"
	if !r1 || len(hash) < 6 {
		return &BadRequest{json}
	}
	return datastore.NewGetAchievementRequest(hash)
}

func validateGetLeaderBoard(req *jsondata.JSONMap) Request {
	hash, r1 := req.GetString("hash")

	if !r1 || len(hash) < 6 {
		jsonRes := "{\"result\": false, \"answer\": \"Missing or Invalid data in getLeaderBoard request\"}"
		return &BadRequest{jsonRes}
	}

	return datastore.NewLeaderBoardRequest(hash)
}

// unregister: (in) json
//    { "name": "[email protected]", "hash":"123456..." }
func validateUnregisterRequest(req *jsondata.JSONMap) Request {
	name, r1 := req.GetString("name")
	hash, r2 := req.GetString("hash")

	s := "{\"result\": false, \"answer\": \"missing or invalid arguments in the request\"}"
	if !r1 || !r2 || len(name) < 6 || len(hash) < 6 {
		return &BadRequest{s}
	}
	return datastore.NewUnregisterRequest(name, hash)
}

//
// {"verb": "syncCoinCounts", "hash": <user_hash>, "count": <count>}
//
func validateSyncCoinCounts(req *jsondata.JSONMap) Request {
	hash, r1 := req.GetString("hash")
	count, r2 := req.GetUInt("count")

	json := "{\"result\": false, \"answer\": \"missing or invalid arguments in syncCoinCount request\"}"
	if !r1 || !r2 || count <= 0 || len(hash) < 6 {
		return &BadRequest{json}
	}
	return datastore.NewSyncCoinCounts(hash, count)
}

//
// { "verb": "getPendingCoinRequests", "hash": <user-id>, "limit": <unsigned integer> }
// { "result": true, "answer" : [zero-or-more{"name": <name>, "count": <unsigned int>}] }
//
func validateGetPendingCoinRequests(req *jsondata.JSONMap) Request {
	hash, r1 := req.GetString("hash")
	limit, r2 := req.GetUInt("limit")

	json := "{\"result\": false, \"answer\": \"missing or invalid arguments in getPendingCoinRequests request\"}"
	if !r1 || !r2 || limit <= 0 || len(hash) < 6 {
		return &BadRequest{json}
	}
	return datastore.NewGetPendingCoinRequests(hash, limit)
}

func validateSetAchievement(req *jsondata.JSONMap) Request {
	hash, r1 := req.GetString("hash")
	achievement, r2 := req.GetUInt("achievement")

	json := "{\"result\": false, \"answer\": \"missing or invalid arguments in setAchievement request\"}"
	if !r1 || !r2 || len(hash) < 6 {
		return &BadRequest{json}
	}
	return datastore.NewSetAchievementRequest(hash, achievement)
}

//
// { "verb": "getScore", "hash": <user-id> , "game": <game-name>}
// { "result": true, "answer" : <score-unsigned-int> }
// { "result": false, "answer" : "invalid user" }
//
func validateGetScore(req *jsondata.JSONMap) Request {
	hash, r1 := req.GetString("hash")
	game, r2 := req.GetString("game")

	json := "{\"result\": false, \"answer\": \"missing or invalid arguments in getScore request\"}"
	if !r1 || !r2 || len(hash) < 6 || len(game) < 6 {
		return &BadRequest{json}
	}

	return datastore.NewGetScoreRequest(hash, game)
}

func ValidateRequest(req *jsondata.JSONMap) *Response {
	err := MissingVerb

	if cmd, res := req.GetString("verb"); res {
		err = InvalidVerb
		if handler := reqHandlers[cmd]; handler != nil {
			return handler(req)
		}
	}
	panic(err)
}

func validateReceiveMessage(req *jsondata.JSONMap) Request {
	to, r1 := req.GetString("receiver") // hash of the receiver
	limit, _ := req.GetUInt("limit")    // ignored, at the moment

	// additionally, we need to record the date and time of this response

	if !r1 || len(to) < 6 {
		jsonRes := "{\"result\": false, \"answer\": \"Missing or Invalid data in receiveMessage request\"}"
		return &BadRequest{jsonRes}
	}

	return datastore.NewReceiveMessage(to, limit)
}

func validateRequestCoins(req *jsondata.JSONMap) Request {
	count, r1 := req.GetUInt("count")
	requester, r2 := req.GetString("requester") // hash
	donor, r3 := req.GetString("donor")         // fb id

	// additionally, we need to record the date and time of this request

	if !r1 || !r2 || !r3 || len(requester) < 6 || len(donor) < 6 || count <= 0 {
		jsonRes := "{\"result\": false, \"answer\": \"Missing or Invalid data in requestCoins request\"}"
		return &BadRequest{jsonRes}
	}
	return datastore.NewCoinsRequest(requester, donor, count)
}

func validateOfferCoins(req *jsondata.JSONMap) Request {
	offer, r1 := req.GetUInt("offer")
	countOnDevice, r2 := req.GetUInt("countOnDevice")
	requester, r3 := req.GetString("requester") // fb id
	donor, r4 := req.GetString("donor")         // hash

	// additionally, we need to record the date and time of this response

	if !r1 || !r2 || !r3 || !r4 || len(donor) < 6 || len(requester) < 6 || offer <= 0 || countOnDevice <= 0 {
		jsonRes := "{\"result\": false, \"answer\": \"Missing or Invalid data in offerCoins request\"}"
		return &BadRequest{jsonRes}
	}

	return datastore.NewCoinsOffer(requester, donor, offer, countOnDevice)
}

func validateRequest(httpReq *http.Request, jsonMap *jsondata.JSONMap) Request {
	var reason string = "missing verb in the request"

	if cmd, res := jsonMap.GetString("verb"); res {
		reason = "Invalid or unknown REST-resource and verb combined in the request (" + httpReq.RawURL + " : " + cmd + ")"
		if handler := reqHandlers[cmd]; handler != nil {
			if isVerbValidForResource(httpReq.URL.Path, cmd) {
				return handler(jsonMap)
			}
		}
	}

	msg := "{\"result\": false, \"answer\": \"" + reason + "\"}"
	return &BadRequest{msg}
}

func parseUpdateParams(req *jsondata.JSONMap) *CheckUpdateRequestParams {
	uid := getUID(req)
	verApp, r1 := req.GetString("verApp")
	verRes, r2 := req.GetString("verRes")
	if !r1 || !r2 {
		return nil
	}

	portraitX := 0
	portraitY := 0
	density := 0
	size := InvalidScreen

	portraitX, _ = req.GetUInt("portraitX")
	portraitY, _ = req.GetUInt("portraitY")
	if portraitX == 0 || portraitY == 0 {
		return nil
	}

	d, _ := req.GetString("density")
	density = screenDensity(d)
	d, _ = req.GetString("screenSize")
	size = screenSize(d)

	p := CheckUpdateRequestParams{uid, verApp, verRes,
		portraitX, portraitY,
		density, size}
	return &p

}

func ValidateRegisterRequest(req *jsondata.JSONMap) *Response {
	name, r1 := req.GetString("name")
	password, r2 := req.GetString("password")
	device, r3 := req.GetString("deviceId")

	if r1 && r2 && r3 {
		osVer, _ := req.GetString("osVersion")
		hasher := sha1.New()
		hasher.Write([]byte(name + password + device))
		fmt.Printf("osVer: %v, hash size: %v, hash sum: %v\n",
			osVer, hasher.Size(), hasher.Sum())
		return nil
	}

	panic("Ill-formed JSON for register request")
}