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))
