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(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 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 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 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 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 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 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)) photo = db.BlobEntity.get_by_id(req_data["avatarPhotoBlobId"]) if photo == None: res_data = {"result": False, "reason": "photo blob not exist"} self.response.write(json.encode(res_data)) return # 이전 사진은 삭제 prev_photo = db.BlobEntity.get_by_id(str(user.avatar_photo_blob_key)) if prev_photo != None: blobstore.delete(prev_photo.blob_key) prev_photo.key.delete() user.avatar_photo_blob_key = photo.blob_key user.put() res_data = {"result": True, "avatarPhotoUrl": photo.blob_url} self.response.write(json.encode(res_data))
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 = "*****@*****.**" recipient = "*****@*****.**" 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 == 'x6jYIE9iH4M59uk': coordenadas = {'latitud':'4.682616', 'longitud': '-74.044110', 'clave':'true', 'punto':'2'} self.response.write(json.encode(coordenadas)) elif punto == '2' and codigo == '5D9MS15a4tRd29A': 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 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 post(self): self.response.content_type = 'application/json' punto = self.request.get('punto') codigo = self.request.get('codigo') if punto == '1' and codigo == '8p8B85pkG5q621F': coordenadas = {'latitud':'4.679904', 'longitud': '-74.044532', 'clave':'true', 'punto':'2'} self.response.write(json.encode(coordenadas)) elif punto == '2' and codigo == '84321H39689Ih8W': 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 post(self): #self.response.out.write("Player Connect post") game_id = self.request.path game_id = game_id.replace('/game/', '') game_id = game_id.replace('/playerConnect', '') username = str(self.request.get('username')) player = ndb.gql("SELECT * FROM Player WHERE name = '" + username + "'").fetch() if len(player) == 0: key = randint(0, 99999999) player = Player(name=username, player_id=key, tokens=1000) player.put() game_status = GameStatus(game_id=int(game_id), name=username, player_id=key, tokens=1000, your_cards_visible=json.encode([]), common_cards_visible=json.encode([]), your_actions=json.encode([]), players=json.encode([])) game_status.put() else: player = player[0] game_status = ndb.gql("SELECT * FROM GameStatus WHERE name = '" + username + "' AND game_id = " + game_id).fetch() if len(game_status) == 0: game_status = GameStatus(game_id=int(game_id), name=username, player_id=player.player_id, tokens=1000, your_cards_visible=json.encode([]), common_cards_visible=json.encode([]), your_actions=json.encode([]), players=json.encode([])) else: game_status = game_status[0] game_status.put() game_retrieved = ndb.gql("SELECT * FROM Game WHERE game_id = " + game_id).fetch() game_retrieved = game_retrieved[0] if game_retrieved.players_current == 6: self.response.out.write("error") else: players_array = json.decode(game_retrieved.players) check_player = 0 for p in players_array: if p == player.name: check_player = 1 if check_player == 0: players_array.append(player.name) game_retrieved.players = json.encode(players_array) game_status.players = game_retrieved.players game_retrieved.players_current += 1 game_retrieved.put() game_status.put() self.response.out.write("ok")
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 post(self): self.response.content_type = 'application/json' codigo = self.request.get('codigo') if codigo == '7x7mFPcBY4qtI7h': validacion = {'equipo': 'liderazgo', 'error_':'false'} self.response.write(json.encode(validacion)) elif codigo == '7J63m3rK7E25MSy': validacion = {'equipo': 'trabajo_en_equipo', 'error_':'false'} self.response.write(json.encode(validacion)) elif codigo == '3Fubt76cBRwjTYa': validacion = {'equipo': 'orientacion_al_logro', 'error_':'false'} self.response.write(json.encode(validacion)) else: validacion = {'equipo': 'ninguno', 'error_':'true'} self.response.write(json.encode(validacion))
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))
def post(self): user = users.get_current_user() useremail = "" if user: useremail = user.email() else: useremail = "public" if authserv.isAuthorised(useremail): doc_id = self.request.get('doc_id') new_title = self.request.get('title') new_eventdate = self.request.get('eventdate') new_tags = self.request.get('tags') new_description = self.request.get('descritption') index = search.Index(_INDEX_NAME) doc = index.get(doc_id) dtSplt = new_eventdate.split('-') docyear = int(dtSplt[0]) docmonth = int(dtSplt[1]) docday = int(dtSplt[2]) """ make a seach document""" nodeMetadata = search.Document( doc_id=doc_id, fields=[ search.AtomField(name='uploader', value=doc.fields['uploader']), search.AtomField(name='nodeID', value=doc.fields['nodeID']), search.TextField(name='title', value=new_title), # search.AtomField(name='filelink', value=filelink), search.TextField(name='description', value=new_description), search.TextField(name='eventdate', value=new_eventdate), search.TextField(name='tags', value=new_tags), search.GeoField(name='place', value=doc.fields['geopoint']), search.DateField(name='eventdatestamp', value=date(docyear, docmonth, docday)), search.DateField(name='stamp', value=datetime.now().date())]) """ put that search document in to the index """ rsp = "" try: search.Index(name=_INDEX_NAME).put(nodeMetadata) rsp = json.encode({'rsp': 'OK', 'msg': 'saved the document'} ) except search.Error, e: rsp = json.encode({'rsp': 'REJECT', 'msg': 'Did NOT SAVE'} )
def accounts_json(request, accounting_universe_uid, page=1, start=0, limit=25): response = Response() accounting_universe = AccountingUniverse.get_by_key_name(accounting_universe_uid) if accounting_universe is None: raise HTTPNotFound retval = [] for total_account in accounting_universe.total_accounts: for aggregate_account in total_account.aggregate_accounts: for simple_account in aggregate_account.accounts: account = { 'uid': simple_account.uid, 'name': simple_account.name, 'description': simple_account.description, 'parent': simple_account.parent_account.uid, } retval.append(account) account = { 'uid': aggregate_account.uid, 'name': '* ' + aggregate_account.name, 'description': aggregate_account.description, 'parent': aggregate_account.parent_account.uid, } retval.append(account) account = { 'uid': total_account.uid, 'name': '** ' + total_account.name, 'description': total_account.description, 'parent': None, } retval.append(account) response.out.write(encode(retval))
def test_post(self): # create widget in DB and get its id widget = copy.copy(self.json_widget) ident = model.Widget.put(widget).key().id() self.assertEqual(1, len(model.Widget.all().fetch(2))) # update widget with the same id through API widget = copy.copy(self.json_widget) widget['email_field'] = '*****@*****.**' response = self.testapp.post('/rest/Widget/' + str(ident), params = json.encode(widget), expect_errors=True, content_type = "application/json; charset=utf-8") self.assertEqual(response.status_int, 200) self.assertEqual(json.decode(response.body)['code'], 200) # get widget with the same id through API and verify that email field is correct response = self.testapp.get('/rest/Widget/' + str(ident), params = self.str_widget, expect_errors=True) self.assertEqual(response.status_int, 200) self.assertEqual(json.decode(response.body)['code'], 200) self.assertEqual(json.decode(response.body)['message']['email_field'], "*****@*****.**")
def post(self): q = Email.all() try: q.filter( "__key__ =", db.Key(self.request.get('i'))) email = q.get() if email.content is None: email.content = self.request.get('content').rstrip() else: email.content = email.content + \ self.request.get('content').rstrip() email.put() obj = { 'success': True, 'msg': '', 'id': str(email.key()), 'to': email.to, 'pos': self.request.get('pos'), 'subject': email.subject, 'content': email.content, } except db.datastore_errors.BadKeyError: obj = { 'success': False, 'msg': "no existe", } self.response.content_type = 'application/json' self.response.headers.add_header('Access-Control-Allow-Origin', '*') self.response.write(json.encode(obj))
def create(self, class_name): logging.info(self.request.arguments()) if self.checkModel(class_name) == False: return if models.BlackList.checkBanned(): return # 文字列からモデルクラス、エンティティ取得 classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name) klass = webapp2.import_string(classPath_str) # マスタデータかどうかチェック & マスターデータだったら管理者以外は作成できないように。 if klass.isMasterData == True and users.is_current_user_admin() == False: logging.warn("管理者以外がマスタデータを作成しようとしました") return False # 保存開始 entity = klass() self.setPropertyFromRequestData(entity, self.request) entity.put() # 出力 out = { "meta": functions.createMetaData(status="ok", code=200, method_name="createCustomObject"), "response": {"objects": [entity.toDict()]}, } self.response.out.write(json.encode(out))
def post(self): save = True msg_error = "" if len(self.request.get('subject')) > 0: subject = self.request.get('subject') else: save = False msg_error = "No se envio asunto" if save is True and len(self.request.get('to')) > 0: to = self.request.get('to') else: save = False msg_error = "No se envio destinatario" if save is True: email = Email(to=to, subject=subject) email.put() obj = { 'success': True, 'msg': '', 'pos': '', 'id': str(email.key()), } else: obj = { 'success': False, 'pos': '', 'msg': msg_error, 'id': '', } self.response.content_type = 'application/json' self.response.headers.add_header('Access-Control-Allow-Origin', '*') self.response.write(json.encode(obj))
def post(self): playername = cgi.escape(self.request.get('playername')) playerpassword = cgi.escape(self.request.get('password')) checkedplayer = Player.check_player_login(playername,playerpassword) self.response.headers['Content-Type'] = 'application/json' self.response.out.write(json.encode(checkedplayer))
def toJSON(self): jsondata = { "Blocks" : self.blocks, "X" : self.X, "Y" : self.Y } return json.encode(jsondata)
def get(self): timestamp = int(round(time.time()*1000)) channel_id_param = self.request.get('channel_id') auth_key_param = self.request.get('auth_key') duration_param = self.request.get('duration') if (channel_id_param == _CHANNEL_ID_FOR_TV8 and auth_key_param == _AUTH_KEY_FOR_TV8 and duration_param): memcache.set(_HLS_MASTER_BASE_URI, timestamp, time=_TTL_1_HOUR) logging.info('received ad trigger with channel_id %s, auth_key %s, timestamp %i, duration %s' % (channel_id_param, auth_key_param, timestamp, duration_param)) self.response.content_type = 'application/json' # for debugging purposes # obj = { # 'duration_param': duration_param, # 'auth_key_param': auth_key_param, # 'channel_id_param': channel_id_param, # 'timestamp': timestamp # } obj = { 'success': True } self.response.write(json.encode(obj)) else: logging.info('INVALID ad trigger with channel_id %s, auth_key %s, timestamp %i, duration %s' % (channel_id_param, auth_key_param, timestamp, duration_param)) self.response.set_status(500) self.response.write('A server error occurred!')
def subscribe( self ): device_token = self.request.get( 'device_token', None ); type = self.request.get( 'type', None ); # ios or android # パラメータが足りなかったらエラー if device_token is None or type is None: functions.printError( "parameter missing" ) return # ios の場合は urbanairship に登録する。 # android の場合はクライアント側のライブラリが # urbanairship への登録までやってくれているので何もしない。 if type == "ios": from openfish.libs import urbanairship import config airship = urbanairship.Airship( config.URBANAIRSHIP_APP_KEY, config.URBANAIRSHIP_MASTER_SECRET )# 2つ目は master secret airship.register( device_token, alias=self.user.ua_alias ) # user のプロパティとして保存 self.user.device_token = device_token self.user.put() logging.info( "%s の device_token を %s として登録しました" % ( str(self.user.key), str(device_token) ) ) # 出力 out = { "meta": functions.createMetaData( status="ok", code=200, method_name="subscribePushNotification" ), }; self.response.out.write( json.encode(out) )
def post(self, registry): """Edit the registry based on the submitted info.""" if not self.user_info or registry.owner != ndb.Key( flat=self.user_info['user_id']): return self.redirect_to('builder-login', next=self.uri_for( 'registry-build', registry_name=registry.registry_name)) request_type = self.request.get('request_type') if request_type == 'add_item': name = self.request.get('name') try: num_wanted = int(self.request.get('num_wanted')) except ValueError: num_wanted = 1 section = self.request.get('section') high_entry = RegistryEntry.query(RegistryEntry.section==section, ancestor=registry.key) \ .order(-RegistryEntry.order) \ .get() if high_entry: high_order = high_entry.order else: high_order = 0.0 entry = RegistryEntry(name=name, num_wanted=num_wanted, parent=registry.key, order=high_order + 1, section=section) entry.put() logging.info(section) retval = { 'num_wanted': num_wanted, 'name': name, 'section': section, 'id': entry.key.urlsafe() } elif request_type == 'delete_item': item_key = self.request.get('item_key') try: k = ndb.Key(urlsafe=item_key) k.delete() except TypeError: item_key = 0 retval = {'item_key': item_key} else: webapp2.abort(405) if not self.request.get('ajax'): # was not an ajax query logging.info("Not AJAX query") return self.redirect_to('registry-build', registry_name=registry.registry_name) logging.info("Return JSON") self.response.content_type = 'application/json' self.response.write(json.encode(retval))
def get(self): self.response.content_type = 'application/json' resp = { 'usage': usage, 'days_left': days_left, 'status': status, 'speed': speed } self.response.write(json.encode(resp))
def get(self): print("inside CREATE PROFILE") upload_url = blobstore.create_upload_url('/rest/uploadProfileImage') print(upload_url) template_values = { 'upload_url': upload_url, } self.response.write(json.encode(template_values))
def toJSON(self): jsondata = { #"image" : self.image, "username": self.key.id(), "password": self.password, "email": self.email, "time": self.time.strftime("%A %d/%m/%Y %H:%M"), "banned": self.banned } return json.encode(jsondata)
def get(self): author = users.get_current_user() name = self.request.get('name') query = Algorithm.query(ancestor=ndb.Key('Python Algorithms', 'scrap')) \ .filter(Algorithm.author == author) \ .filter(Algorithm.name == name) self.response.content_type = 'application/json' try: for version in query.fetch(None): version.key.delete() self.response.write(json.encode({'result': 'Deleted "%s"' % name})) info('User %s deleted "%s"' % ( author.email(), self.request.get('name'), )) except Exception as e: self.response.write( json.encode( {'result': 'Could not delete "%s": %s' % (name, e)}))
def get(self): query = Reading.query() query = query.order(-Reading.date) last_readings = query.fetch(100) #iter() out = [] i = 1 for reading in last_readings[-1::-1]: out.append([i, reading.temperature]) i += 1 self.response.content_type = 'application/json' self.response.write(json.encode(out))
def post(self): word = self.request.get("word", '') self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.content_type = 'application/json' if not word: obj = {"error": True, "message": "No word was specified"} self.response.write(json.encode(obj)) return message = Word.Remove(word).get_result() if message: obj = { "error": True, "message": "Error removing word {}: {}".format(word, message) } else: obj = { "error": False, "message": "Successfully removed word {}".format(word) } self.response.write(json.encode(obj))
def get(self, game_id, user_id): self.response.content_type = 'application/json' obj = { 'id': 'some var', 'name': 'some var', 'uploader': 'some var', 'descripction': 'some var', 'category': 'some var', 'uploaddate': 'some var', } self.response.write(json.encode(obj))
def getSubscriptionRequests(self): if users.is_current_user_admin(): subscriptionRequests = [] subscriptionRequestQuery = SubscriptionRequest.query() for subscriptionRequest in subscriptionRequestQuery.iter(): subscriptionRequests.append( {'serviceUrl': subscriptionRequest.serviceUrl}) self.response.content_type = 'application/json' self.response.write(json.encode(subscriptionRequests)) else: self.error(403)
def post(self): account = AccountRepository.getUserAccount() if account.admin == 0: return false id = self.request.get("id") title = self.request.get("title") text = self.request.get("text") UpdateRepository.upsertUpdate(id, account, title, text) self.response.out.write(json.encode({}))
def get(self): driver_name = self.request.get("driverName") taxi = Taxi(driver_name=driver_name) taxi_key = taxi.put() taxi_key_urlsafe = taxi_key.urlsafe() self.response.content_type = 'application/json' response_json = {'success': 'OK', 'taxiKey': taxi_key_urlsafe} self.response.write(json.encode(response_json))
def post(self): act = self.request.get('act') #action uid = self.request.get('uid') #unique comment id print act + "called by " + uid ret = None action_method = getattr(self, "act_" + act) #change to act ret = action_method() json_str = json.encode(ret) self.response.write(json_str)
def get(self): #instantiate email connection, source: https://stackabuse.com/how-to-send-emails-with-gmail-using-python/ #removed #retrieve all homechef objects from database homechef_qry = HomeChef.query() homechefs = homechef_qry.fetch() #For every homechef, do the following: for homechef in homechefs: #Get the homechef's list of subscriptions subscribedTo = homechef.subscribed_to #Create a list to store the meals from all that homechef's subscriptions mealsFromAllSubscriptions = list() #Populate that list with the meals of each subscription for email in subscribedTo: meals_qry = Meals.query(Meals.email == email) meals_result = meals_qry.fetch() for meal in meals_result: mealsFromAllSubscriptions.append(meal) #Send email to every homechef with a list of meals from his subscriptions email_from = '*****@*****.**' email_to = homechef.email email_subject = 'Delicious Meals from Your Subscriptions' email_body = '<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"></head><body>' email_body = ' <a href=" https://abhilasha230587.appspot.com/index.html#/home">Order Now on FamilyFlavors</a></br></br>' for meal in mealsFromAllSubscriptions: email_body += '<font size="8">' + meal.name + '</font> </br>' email_body += '<img src="' + meal.meal_image_url + 'style="width:200px;height:150px;"></br>' email_body += '<font size="6">' + meal.description + '</font> </br>' email_body += '<font size="6">' + meal.price + '</font> </br>' email_body += '</br>' email_body += '</body></html>' #mail.send_mail(sender='*****@*****.**', subject=email_subject, body=email_body) mail.send_mail(email_from, email_to, email_subject, email_body) #msg = MIMEMultipart() #msg['From'] = email_from #msg['To'] = homechef.email #msg['Subject'] = email_subject #msg.attach(MIMEText(email_body,'plain')) #text = msg.as_string() #server.sendmail(email_from,email_to,text) #server.quit() obj = { 'email_sent': 'email sent', } self.response.content_type = 'application/json' self.response.write(json.encode(obj))
def get(self): self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.content_type = 'application/json' word_list = self.request.get("name", '') if not word_list: raise endpoints.BadRequestException( "No word list name was specified") entry = WordList.Get(word_list).get_result() if not entry: raise endpoints.NotFoundException( "Cannot find word list with name {}".format(word_list)) self.response.write(json.encode(entry.GetWords()))
def GetViewForError(self, error): str_err_type = str(error[0]) serializable_error = { "error": str(error[1]), } if error[0] in self.error_codes: code = self.error_codes[error[0]] else: code = self.default_error_code return [code, json.encode(serializable_error)]
def get(self, game_key): self.response.content_type = 'application/json' game = GameDB.get(game_key) obj = { 'id': 'cambiar', 'name': game.name, 'uploader': game.uploader, 'description': game.description, 'category': game.category, 'uploaddate': str(game.uploaddate), } self.response.write(json.encode(obj))
def post(self): word = self.request.get("word", '') self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.content_type = 'application/json' if not word: obj = {"error": True, "message": "No word was specified"} self.response.write(json.encode(obj)) return try: added = Word.Add(word) if added: message = "Successfully added word {}".format(word) else: message = "word {} already exists".format(word) obj = {"error": False, "message": message} except Exception as e: message = str(e) obj = { "error": True, "message": "Error adding word {}: {}".format(word, message) } self.response.write(json.encode(obj))
def return_json(self, obj={}, status_code=200): self.response.content_type = 'application/json' self.response.set_status(status_code) try: def json_serial(obj): """JSON serializer for objects not serializable by default json code""" if isinstance(obj, datetime) or isinstance(obj, date): serial = obj.isoformat() return serial else: raise TypeError("Type not serializable") self.response.write(json.encode(obj, default=json_serial)) except Exception, e: warn(e) obj = {"error": "Error when trying to json encode the response"} self.response.write(json.encode(obj))
def get(self): user = users.get_current_user() if check_creds(user, self.check_u(), admin=True) or users.is_current_user_admin(): admin = hold_creds(user, self.check_u()) year = self.request.get('year') self.response.content_type = 'application/json' raw_data = m.Standard.retrieve_data(year) obj = google_chart_data_wrangle(raw_data) self.response.write(json.encode(obj)) else: self.redirect('/ouch')
def add_users(group_key, usernames): #Find the user to add the key to group = Group.find_by_key(group_key) if (group == None): raise Exception("Invalid group key") #Get the pending usernames and current usernames group_usernames = JSON.decode(group.usernames) group_pending_usernames = JSON.decode(group.pending_usernames) usernames = JSON.unquote(usernames) for username in usernames: #Find the user to add the key to user = User.find_by_username(username) if (user != None): if (user.username not in group_pending_usernames) and (user.username not in group_usernames): #Add the username to the list of pending users group_pending_usernames.append(user.username) #Add the group to the list of user groups user_groups = JSON.decode(user.groups) user_groups.append(group_key) user.groups = JSON.encode(user_groups) user.increment_version() user.put() group.pending_usernames = JSON.encode(group_pending_usernames) group.increment_version() group.put() #Return the currently pending users return str(json.dumps(group_pending_usernames)).replace("\\\"","\"")
def get(self): url = self.request.get('url', '') exists = False if url: result = urlfetch.fetch(url=url, method=urlfetch.HEAD, deadline=10) if result.status_code == 200: exists = True self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.content_type = 'application/json' obj = { 'url': url, 'exists': exists, } self.response.write(json.encode(obj))
def act_check(self): uid = self.request.get("uid") msgs = msgbox.get(uid) #自分のmsgbox if not msgs: msgs = [ json.encode({ "type": "room_info", "room_list": room_manager.getMembersCountList() }) ] msgbox[uid] = [] #一度取得したら空に return {"act": "check_ret", "ret": msgs}
def send_to(self, fr, targets, json_obj, include_me=False): #本来はwebsocketでサーバーから先の入出者へ、 #通知するつもりだったが、push通知をやめて暫定的にpollingで取得するようにした #(websocket実装のipv6対応に断念したため) #受信箱に通知情報を足して、ポーリングの取得に備える json_str = json.encode(json_obj) if targets == None: targets = msgbox.keys() for ts in targets: if fr != ts or include_me: #自分がtargetsに含まれている場合に対象とするか msgbox[ts].append(json_str) print msgbox[ts]
def post(self): act = self.request.get("act") #action uid = self.request.get("uid") #ユーザid print act + " called by " + uid ret = None #actionに対応するメソッド実行 action_method = getattr(self, "act_" + act) ret = action_method() #json文字列にエンコードしてレスポンス json_str = json.encode(ret) self.response.write(json_str)
def get(self): entries = Word.List().get_result() words = [] for entry in entries: word = {"word": entry.word, "audio": []} for audio in entry.audio: word["audio"].append({ "source": audio.source, "link": audio.link, }) words.append(word) obj = {"error": False, "words": words} self.response.write(json.encode(obj))
def get(self): # allow work depending on locale locale = self.session['locale'] if self.request.get('locale'): locale = self.request.get('locale') i18n.get_i18n().set_locale(locale) # get the data from the handler result = self.getData(locale) try: result['etag'] = "W/\"" + hashlib.md5( self.__class__.__name__ + self.etagStamp()).hexdigest() + "\"" except: pass self.response.set_status(200) # support jsonp if self.request.get('callback'): self.response.headers['Content-Type'] = 'application/javascript' resultText = self.request.get('callback') + "(" + json.encode( result) + ");" else: self.response.headers['Content-Type'] = 'application/json' resultText = json.encode(result) self.response.write(resultText)
def get(self): print("inside GetTags") tags_qry = Tags.query() tags_result = tags_qry.fetch() print('::::::::::::::::::::', tags_result) tagslist = list() for tag in tags_result: obj = {'tag': tag.name} tagslist.append(obj) self.response.content_type = 'application/json' self.response.write(json.encode(tagslist))
def get(self): walkers = DogWalker.query( DogOwner.email == users.get_current_user().email()) id = None for account in walkers: id = account.key.id() self.response.headers['Content-Type'] = 'application/json' data = { 'owners': [owner.to_json() for owner in DogOwner.query()], 'walkers': [walker.to_json() for walker in DogWalker.query()], 'requests': [request.to_json() for request in WalkRequest.query()], 'user_id': id, } return self.response.out.write(json.encode(data))
def getExistingSubscriptions(self): user = users.get_current_user() if user: existingSubscriptions = [] serviceIdsQuery = UserSubscription.query( projection=[UserSubscription.serviceId], distinct=True) for projectedUserSubscription in serviceIdsQuery.iter(): existingSubscriptions.append( {'serviceId': projectedUserSubscription.serviceId}) self.response.content_type = 'application/json' self.response.write(json.encode(existingSubscriptions)) else: self.error(403)
def get(self): # searches title and description print("inside GET of SearchMeals") tags = self.request.get('tags') if (tags): tags = tags.split(',') print("tags : ", tags, len(tags)) theme = self.request.get('theme') if (theme): theme = theme.split(',') print("theme : ", theme, len(theme)) meals_qry = Meals.query() if (len(theme) > 0): condition1 = Meals.theme.IN(theme) print("condition1 : ", condition1) meals_qry = Meals.query(condition1) if (len(tags) > 0): condition2 = Meals.tags.IN(tags) print("condition2", condition2) if (len(theme) > 0): meals_qry = Meals.query(condition1, condition2) else: meals_qry = Meals.query(condition2) #meals_qry = Meals.query(condition1,condition2) print(meals_qry) meals_result = meals_qry.fetch() # Iterate through attributes mealslist = list() for meal in meals_result: obj = { 'mealname': meal.name, 'mealdes': meal.description, 'mealq': meal.quantity, 'mealp': meal.price, 'meal_image': meal.meal_image_url, 'meal_theme': meal.theme, 'meal_tag': meal.tags, 'meal_chef': meal.email, 'meal_latitude': meal.geopt.lat, 'meal_longitude': meal.geopt.lon } mealslist.append(obj) self.response.content_type = 'application/json' self.response.write(json.encode(mealslist))