Python json.encode函数代码示例

	def create( self ):
		photo = self.request.get( "photo", None )

		# photo がなかったらエラー
		if photo is None:
			message = "parameter missing"
			logging.warn( message )
			out = { "meta": functions.createMetaData( status="fail", code=400, message=message, method_name="createPhoto" ) };
			self.response.out.write( json.encode(out) )
			return

		logging.info( "サイズは%d KB"%( len(photo)/1000 ) )

		# 保存
		entity = models.Photo()
		if self.isBase64( photo ) == True:
			logging.info( "Flashから渡ってきたので base64decode します" )
			photo_bin = base64.b64decode( photo )
			entity.setBlob( photo_bin )
		else:
			logging.info( "HTMLフォームから渡って来ました" )
			entity.setBlob( photo )
		entity.user_key = self.user.key if self.user else None
		entity.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createPhoto" ),
			"response": {
				"photos":[
					entity.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

	def create( self ):
		content = self.request.get( 'content' );

		# content がなかったらエラー
		if content == "":
			message = "parameter missing"
			logging.warn( message )
			out = { "meta": functions.createMetaData( status="fail", code=400, message=message, method_name="showPosts" ) };
			self.response.out.write( json.encode(out) )
			return

		# 保存
		post = models.Post()
		post.content = content
		if self.user:
			post.user_key = self.user.key
		post.created_at = int(time())
		post.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createPost" ),
			"response": {
				"posts":[
					post.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

	def leave(user_key, group_key):

		#Find the user to add the key to
		user = User.find_by_key(user_key)
		if (user == None):
			raise Exception("Invalid key")

		#Find the user to add the key to
		group = Group.find_by_key(group_key)
		if (group == None):
			raise Exception("Invalid group key")

		#Remove the user from the pending users
		group_usernames = JSON.unquote(group.usernames)
		group_usernames.remove(user.username)
		group.usernames = JSON.encode(group_usernames)
		group.increment_version()
		group.put()	

		#Remove the list from the users lists
		user_groups = JSON.unquote(user.groups)
		user_groups.remove(group_key)
		user.groups = JSON.encode(user_groups)
		user.increment_version()
		user.put()

		return "Group left"

	def create(user_key, name=""):

		#Find the user to add the key to
		user = User.find_by_key(user_key)
		if (user == None):
			raise Exception("Invalid key")

		if (name == ""):
			name = "Untilted"

		# Set the list to empty
		usernames = [user.username]
		pending_usernames = []

		# Add the new item list to the database
		group = Group(name=name, usernames=JSON.encode(usernames),
			pending_usernames=JSON.encode(pending_usernames), version=0,photo="",photo_version=0)

		group_key = (group.put()).urlsafe()
		user_groups = JSON.decode(user.groups)
		user_groups.append(group_key)
		user.groups = JSON.encode(user_groups)
		user.increment_version()
		user.put()

		return group_key

	def accept(user_key, group_key):

		#Find the user to add the key to
		user = User.find_by_key(user_key)
		if (user == None):
			raise Exception("Invalid key")

		#Find the user to add the key to
		group = Group.find_by_key(group_key)
		if (group == None):
			raise Exception("Invalid group key")

		#Remove the user from the pending users
		group_pending_usernames = JSON.unquote(group.pending_usernames)
		group_pending_usernames.remove(user.username)
		group.pending_usernames = JSON.encode(group_pending_usernames)

		#Put the user in the confirmed users
		group_usernames = JSON.unquote(group.usernames)
		group_usernames.append(user.username)
		group.usernames = JSON.encode(group_usernames)
		group.increment_version()
		group.put()

		user.increment_version()

		return "Group request accepted"

    def post(self, email):

        # Http 쏘기 위한 공옹 루틴
        self.response.headers.add_header("Access-Control-Allow-Origin", "*")
        self.response.content_type = "application/json"

        user = db.UserEntity.get_by_id(email)
        if user == None:
            res_data = {"result": False, "reason": "email not exist"}
            self.response.write(json.encode(res_data))
            return

        # 패스워드 틀림
        req_data = json.decode(cgi.escape(self.request.body))
        if user.password != req_data["password"]:
            res_data = {"result": False, "reason": "password not match"}
            self.response.write(json.encode(res_data))
            return

        # 결과 리턴
        token = secret.get_jwt(user.auth_type, user.email, user.name)
        res_data = {
            "result": True,
            "token": token,
            "isWorking": user.is_working,
            "totalWorkingSeconds": (datetime.now() - user.work_start_date_time).total_seconds(),
        }
        if user.intro_text != None:
            res_data["introText"] = user.intro_text
        if user.avatar_photo_blob_key != None:
            userPhoto = db.BlobEntity.get_by_id(str(user.avatar_photo_blob_key))
            if userPhoto != None:
                res_data["avatarPhotoUrl"] = userPhoto.blob_url
        self.response.write(json.encode(res_data))

    def show(self, class_name):
        id = self.request.get("id", None)
        if id is None:
            out = {
                "meta": functions.createMetaData(
                    status="fail", code=400, method_name="showObjects", message="parameter missing"
                )
            }
            self.response.out.write(json.encode(out))
            return

            # 文字列からモデルクラス取得
        classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name)
        klass = webapp2.import_string(classPath_str)
        obj = klass.get_by_id(int(id))

        if obj and obj.is_deleted == False:
            out = {
                "meta": functions.createMetaData(status="ok", code=200, method_name="showObjects"),
                "response": {"objects": [obj.toDict(full=True)]},
            }
        else:
            out = {
                "meta": functions.createMetaData(
                    status="fail", code=400, method_name="showObjects", message="object not found"
                )
            }

        self.response.out.write(json.encode(out))

	def login( self ):
		login = self.request.get( 'login', None );
		password = self.request.get( 'password', None );
		logging.info( "login=%s password=%s" % (login,password) );

		# パラメータチェック
		if (login is None) or (password is None):
			out = { "meta": functions.createMetaData( status="fail", code=400, cc_code=1000, message="login and password required") };
			logging.error( "login and password required" );
			self.response.out.write( json.encode(out) )
			return

		# ログインしようとしているユーザーがメアドを verify 済みかチェック
		auth_id = "own:"+ login
		m = self.user_model
		q = m.query( m.auth_ids==auth_id, m.verified==True )
		result = q.get();
		if result is None:
			out = { "meta": functions.createMetaData( status="fail", code=400, cc_code=1000, message="ユーザーが存在しないか、メールアドレス認証が完了していません") };
			logging.error( "ユーザーが存在しないか、メールアドレス認証が完了していません" );
			self.response.out.write( json.encode(out) )
			return

		user = None
		userInfo = self.auth.get_user_by_password( "own:"+ login, password, True, True, True )

		# 2013/01/06 以前のバージョンは頭に「own:」がついてなかったので、それにも対応。	
		if userInfo is None:
			logging.info( "2013/01/06 以前のバージョン方式でログインします" );
			userInfo = self.auth.get_user_by_password( login, password, True, True, True )

		if userInfo is None:
			# ログイン失敗
			logging.error( "Invalid email/username or password." );
			out = {
				"meta": functions.createMetaData(
					status="fail", code=401, cc_code=1000, message="Invalid email/username or password."
				),
			};
			self.response.out.write( json.encode(out) )
			return
		
		# ログイン成功
		user = User.get_by_id( userInfo["user_id"] )
		sessionId = self.serialize_user_token( auth_info=userInfo )
		out = {
			"meta": {
				"status": "ok",
				"code": 200,
				"method_name": "loginUser",
				"session_id": sessionId,
			},
			"response":{
				"users": [
					user.toDict( full=True ),
				],
			},
		};	
		self.response.out.write( json.encode(out) )

    def post(self):
        game_id = self.request.path
        game_id = game_id.replace('/game/', '')
        game_id = game_id.replace('/action', '')
        username = str(self.request.get('player'))
        player = ndb.gql("SELECT * FROM Player WHERE name = '" + username + "'").fetch()
        player = player[0]
        game_status = ndb.gql("SELECT * FROM GameStatus WHERE name = '" + username + "' AND game_id = " + game_id).fetch()
        game_status = game_status[0]
        action = str(self.request.get('action'))
        if action == "bet":
            value = int(self.request.get('value'))
            if value > player.tokens:
                self.response.out.write("Bet more than the number of tokens you have")
            else:
                player.tokens -= value
                game_status.tokens -= value
                actions_array = json.decode(game_status.your_actions)
                actions_array.append("play")
                game_status.your_actions = json.encode(actions_array)
                player.put()
                game_status.put()
                self.response.out.write("ok")
        elif action == "play":
            dealer = ndb.gql("SELECT * FROM Dealer WHERE game_id = " + game_id).fetch()
            dealer = dealer[0]
            deck = json.decode(dealer.deck)
            card1 = choice(deck)
            deck.remove(card1)
            card2 = choice(deck)
            deck.remove(card2)
            player_cards = [card1, card2]
            game_status.your_cards_visible = json.encode(player_cards)
            game_status.put()
            check_games = ndb.gql("SELECT * FROM GameStatus WHERE game_id = " + game_id).fetch()
            check_num = 1
            for game_s in check_games:
                if len(json.decode(game_s.your_cards_visible)) != 2:
                    check_num = 0
            if check_num == 1:
                d_card1 = choice(deck)
                deck.remove(d_card1)
                d_card2 = choice(deck)
                deck.remove(d_card2)
                d_visible = json.decode(dealer.dealer_card_v)
                d_visible.append(d_card1)
                dealer.dealer_card_v = json.encode(d_visible)
                dealer.dealer_card_n = d_card2
            dealer.deck = json.encode(deck)
            dealer.put()
            self.response.out.write("ok")
        # elif action == "draw":
        #
        # elif action == "fold":
        #
        # elif action == "doubledown":

        else:
            self.response.out.write("error")

	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );

		# パラメータが足りなかったらエラー
		if target_model is None or target_id is None:
			message = "parameter missing"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createReport", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からターゲットのモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );

		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = "target object not found"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createReport", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 保存
		entity = models.Report()
		entity.target_key = target_obj.key
		entity.user_key = self.user.key if self.user else None
		entity.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createReport" ),
			"response": {
				"reports":[
					entity.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

		# 管理者にメール
		sender_address = "[email protected]"
		recipient = "[email protected]"
		subject = "通報を確認してください。"
		targetKey_str = str( target_obj.key.id() )
		modelName = target_model.capitalize().encode()
		gql = "SELECT * FROM "+ modelName +" where __key__ = Key( '"+ modelName +"', "+ targetKey_str +" )"

		body = """
通報がありました。
ターゲットのkeyは %(targetKey_str)s です

検索用 GQL は以下のとおりです。
%(gql)s

""" % locals()
		mail.send_mail( sender_address, recipient, subject, body )

	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );

		# パラメータが足りなかったらエラー
		if target_model is None or target_id is None:
			message = "parameter missing"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# ゲストならエラー
		if self.user is None:
			message = "login required"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=401, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からターゲットのモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );

		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = "target object not found"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 重複チェック
		query = models.Like.query( models.Like.target_key==target_obj.key, models.Like.user_key==self.user.key, models.Like.is_deleted==False )
		if query.get():
			message = "already liked"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createLike", message=message )};
			self.response.out.write( json.encode(out) )
			return			

		# 保存
		entity = models.Like()
		entity.target_key = target_obj.key
		entity.user_key = self.user.key
		entity.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createLike" ),
			"response": {
				"likes":[
					entity.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );
		content = self.request.get( 'content', None );
		rating = self.request.get( 'rating', None );


		# パラメータが足りなかったらエラー
		if content is None or target_model is None or target_id is None:
			message = "parameter missing"
			logging.error( message )
			out = {
				"meta": functions.createMetaData( status="fail", code=400, method_name="createComment", message=message ),
			};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );


		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = target_model +"#"+ target_id +" is not found"
			logging.error( message )
			out = {
				"meta": functions.createMetaData( status="fail", code=400, method_name="createComment", message=message ),
			};
			self.response.out.write( json.encode(out) )
			return

		# 保存
		comment = models.Comment()
		comment.content = content
		comment.rating = rating
		comment.target_key = target_obj.key
		if self.user:
			comment.user_key = self.user.key
		comment.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createComment" ),
			"response": {
				"comments":[
					comment.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

 def post(self):
     self.response.content_type = 'application/json'
     punto = self.request.get('punto')
     codigo = self.request.get('codigo')
     if punto == '1' and codigo == '48yB8dH4V58xbRx':
         coordenadas = {'latitud':'4.680569', 'longitud': '-74.047702', 'clave':'true', 'punto':'2'}
         self.response.write(json.encode(coordenadas))
     elif punto == '2' and codigo == 'Ug1195M928451LU':
         coordenadas = {'latitud':'4.676829', 'longitud': '-74.048194', 'clave':'true', 'punto':'3'}
         self.response.write(json.encode(coordenadas))
     else:
         coordenadas = {'latitud':'0', 'longitud': '0', 'clave':'false'}
         self.response.write(json.encode(coordenadas))

	def _train( self ):
		params = {
			"content": "卵かけご飯",
			"categories": json.encode(["1","2"]),
		}
		request = webapp2.Request.blank( '/v1/bayes/train', POST=params )
		response = request.get_response( openfish.main.app )

		params = {
			"content": "これは筆です",
			"categories": json.encode(["3","4"]),
		}
		request = webapp2.Request.blank( '/v1/bayes/train', POST=params )
		response = request.get_response( openfish.main.app )

def _upsert_member_or_volunteer_info(list_member, sheet_dict, fields, typename):
    """Helper for `upsert_member_info()` and `upsert_volunteer_info()`.
    """
    if list_member:
        # Update existing
        _update_mailchimp_record_from_dict(list_member, sheet_dict, fields, typename)
        url = 'members/%s' % list_member['id']
        logging.info('MailChimp: updating %s from %s', list_member, sheet_dict)
        _make_request(url, 'PATCH', body=json.encode(list_member))
    else:
        # Create new
        list_member = _create_mailchimp_record_from_dict(sheet_dict, fields, typename)
        url = 'members'
        logging.info('MailChimp: creating %s from %s', list_member, sheet_dict)
        _make_request(url, 'POST', body=json.encode(list_member))