def get(self): """ Generate a response to /tile?x=<tileX>&y=<tileY> If a record exists in the datastore for tileX, tileY, returns a png image from the blobstore corresponding to that tile. Otherwise, returns a 404 error status. """ #Get Parameters x = int(self.request.get('x')) y = int(self.request.get('y')) #Get record for tile from the datastore query = Tile.gql("WHERE x = :1 AND y = :2", x, y) myTile = query.get() if myTile is None: #No corresponding tile data, return 404 status self.response.set_status(404) else: #Set headers indicating response is a png image self.response.headers["content-type"] = "image/png" #Get png image from blobstore blob_reader = blobstore.BlobReader(myTile.blob_key) #Return the image as the response. self.response.write(blob_reader.read())
def get(self): #move the unit towards the x and y goto positions #xy = re.match('tile(\d+)', self.request.get("tile_id")).groups() x_goto = int(self.request.get("x-goto")) y_goto = int(self.request.get("y-goto")) unitID = int(re.match('unit(\d+)', self.request.get("unitid")).group(1)) destinationTile = Tile.gql("where x = :1 ans y = :2",x_goto, y_goto); if destinationTile.type.canTravel: # just select the unit with that id unit = Unit.get_by_id(unitID) if unit.x > x_goto: unit.x = unit.x - 1 elif unit.x < x_goto: unit.x = unit.x + 1 if unit.y > y_goto: unit.y = unit.y - 1 elif unit.y < y_goto: unit.y = unit.y + 1 unit.put() self.response.out.write("ok") else: self.response.out.write("obstructed")
def get(self, location=''): """ Shows login button if not logged in, otherwise shows logout. Creates a new channel for use with live updates and chat. If location is unspecified, use a random initial tile. Output created using template index.html :param location: x, y of tile to display when opening the graffiti wall """ #Check if user is logged in. user = users.get_current_user() if user: #If so, show logout button login_url = users.create_logout_url(self.request.uri) login_label = 'logout' user_login = 1 else: #If not, show login button login_url = users.create_login_url(self.request.uri) login_label = 'login' user_login = 0 #For live updates token = self.session.get('token') if token is None: channel_id = (str(datetime.now()) + "," + str(random.randint(1, 10000))) token = channel.create_channel(channel_id) self.session['channel_id'] = channel_id self.session['token'] = token ch = UpdateChannel(channel_id=channel_id) ch.put() #Get random initial tile rand_num = random.random() tile = Tile.gql("WHERE rand_num >= :1 ORDER BY rand_num", rand_num).get() if tile is None: locX = 0 locY = 0 else: locX = tile.x locY = tile.y #Output from template template = jinja_environment.get_template('index.html') self.response.out.write(template.render( login_url=login_url, login_label=login_label, token=token, locX=locX, locY=locY, adnum=random.randint(0, 4), user_login=user_login))
def get(self): map = memcache.get("map") HeightMapData = FetchImage("http://humanitymmo.appspot.com/static/earthmini.png") w,h = HeightMapData[:2] # should get the tiles, within proximity of units. # foreach unit, get tiles within range of the unit # in this instance limit it to 1 unit only unit = Unit.get_by_id( int(self.request.get("id")) ) json = {"tiles":[],"enemyunits":[]} fov = 2 # fov is how many tiles a unit can see around it xleft = max(unit.x - fov, 0) xright = min(unit.x + fov + 1, w) ytop = max(unit.y - fov, 0) ybottom = min(unit.y + fov + 1, h) # get heightmap based tiles for x in range(xleft, xright): for y in range(ytop, ybottom): # is the tile in the datastore curTile = Tile.gql("where x = :1 and y = :2", x,y) if curTile.count() > 0: if curTile.type.canTravel: curAlt = 80 else: curAlt = 81 json["tiles"].append( {"x":curTile.x,"y":curTile.y,"alt":curAlt} ) else alt = GetHeightAt(x,y,HeightMapData) json["tiles"].append( {"x":x, "y":y, "alt":alt } ) # write to datastore t = Tile() t.x = x t.y = y t.height = alt if alt < 81: # get tile type where name = water, then reference it else: # get tile type for land t.put() self.response.out.write(demjson.encode(json))
def get(self): #Assure that the user is logged in #There is no way of mocking the user servise #As the system that google app engine provides deos not work user = users.get_current_user() if user: self.testbed = testbed.Testbed() self.testapp = webtest.TestApp(app) #activates the testbed (Used for creating face DB and blobstore) #Swaps the fake systems in for the real systems #Should make this only work offline self.testbed.activate() #Initializes the fake blobstore and datastore self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() ########################## # MainPage Unit Testing ########################## AllParts = 0 #Unit test for MainPage (MainPage_test1) #Checks to assure that the main page can load try: response = self.testapp.get('/') MainPage_test1 = "<font color=green>Passed</font>" #Unit test for MainPage (MainPage_test3) #Checks to assure that the page has a section "wall" try: response.mustcontain('<section id="wall">') MainPage_test3 = "<font color=green>Passed</font>" AllParts = AllParts + 1 except: MainPage_test3 = ("<font color=red>Failed, the main " + "page did not contain a section with ID wall.</font>") #Unit test for MainPage (MainPage_test4) #Checks to assure that the page has the directional scrolling divs try: response.mustcontain('<div id="left">') response.mustcontain('<div id="right">') response.mustcontain('<div id="top">') response.mustcontain('<div id="bottom">') response.mustcontain('<div id="top_left">') response.mustcontain('<div id="top_right">') response.mustcontain('<div id="bottom_left">') response.mustcontain('<div id="bottom_right">') MainPage_test4 = "<font color=green>Passed</font>" AllParts = AllParts + 1 except: MainPage_test4 = ("<font color=red>Failed, the main page " + "did not contain a section with ID wall.</font>") #Unit test for MainPage (MainPage_test2) #Checks to assure that the page has the specified sections if AllParts == 2: MainPage_test2 = "<font color=green>Passed</font>" else: MainPage_test2 = ("<font color=red>Failed, this is " + "not the page as it was intended..</font>") except: MainPage_test1 = ("<font color=red>Failed, the main page " + "did not respond at all.</font>") MainPage_test3 = ("<font color=red>Can't be run " + "if test 1 fails.</font>") #Unit test for MainPage (MainPage_test4) #Check to assure that the random tile is retrieved correctly #Creating fake tile to test tile reading with open("UnitTestTile.png", "rb") as image_file: imageFile = image_file.read() image_file.close() blob_key = 'TestBlobkey' self.testbed.get_stub('blobstore').CreateBlob(blob_key, imageFile) #rand_num=1 to be always selected in a random selection Tile(x=-12, y=-1, blob_key=blobstore.BlobKey(blob_key), rand_num=1).put() try: response = self.testapp.get('/') try: response.mustcontain('<input id="locX" type="hidden" value="-12">') response.mustcontain( '<input id="locY" type="hidden" value="-1">') MainPage_test5 = "<font color=green>Passed</font>" except: MainPage_test5 = ("<font color=red> The start location " + "was not correct. </font>") except: MainPage_test5 = ("<font color=red> The location based page " + "failed to load. </font>") ########################## # GetTile Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() #Creating fake tile to test tile reading with open("UnitTestTile.png", "rb") as image_file: imageFile = image_file.read() image_file.close() with open("UnitTestTile2.png", "rb") as image_file2: imageFile2 = image_file2.read() image_file2.close() blob_key = 'TestBlobkey' self.testbed.get_stub('blobstore').CreateBlob(blob_key, imageFile) Tile(x=0, y=0, blob_key=blobstore.BlobKey(blob_key), rand_num=random.random()).put() params = {'x': 0, 'y': 0} #Unit test for get tile (GetTile_test1) #Checks to assure that the file can load at all try: response = self.testapp.get('/tile', params) GetTile_test1 = "<font color=green>Passed</font>" #Unit test for get tile (GetTile_test2) #Checks to assure that the file can load correctly try: response.mustcontain(imageFile) GetTile_test2 = "<font color=green>Passed</font>" except: GetTile_test2 = ("<font color=red>Failed, the " + "response did not contain the test image file</font>") #Unit test for get tile (GetTile_test3) #Checks to assure that the mach in test 1 is not erroneous try: response.mustcontain(imageFile2) GetTile_test3 = ("<font color=red>Failed, the tile " + "retrieved does not correspond to the tile put in.</font>") except: GetTile_test3 = "<font color=green>Passed</font>" except: GetTile_test1 = ("<font color=red>Failed, there was no " + "response from the mock database.</font>") GetTile_test2 = ("<font color=red>Can't be run " + "if test 1 fails.</font>") GetTile_test3 = GetTile_test2 #Unit test for get tile (GetTile_test4) #Checks to assure that a tile that does not #exist in the database does not load params = {'x': 0, 'y': 1} try: self.testapp.get('/tile', params) GetTile_test4 = ("<font color=red>The load did not " + "fail as it was intended to</font>") except: GetTile_test4 = "<font color=green>Passed</font>" ########################## # SaveTile Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() #We can't actualy create an object in the test bed Datastore with open("UnitTestTile.png", "rb") as image_file: imageFile = base64.b64encode(image_file.read()) image_file.close() #The perameters to create a blob at x=0,y=0 params = {'x': 0, 'y': 0, 'data': imageFile} #Test if there is even a responce from /save try: response = self.testapp.post('/save', params) if response.status_int == 200: #test to see if the created tile actualy exists query = Tile.gql("WHERE x = :1 AND y = :2", 0, 0) myTile = query.get() if myTile is None: SaveTile_test1 = ("<font color=red>The tile data could not be retrieved from the database.</font>") SaveTile_test2 = ("<font color=red>Test 2 requires test 1 to succeed.</font>") else: SaveTile_test1 = ("<font color=green>Passed</font>") oldblobkey = myTile.blob_key try: response = self.testapp.post('/save', params) if response.status_int == 200: query = Tile.gql("WHERE x = :1 AND y = :2", 0, 0) myTile = query.get() if myTile.blob_key == oldblobkey: SaveTile_test2 = ("<font color=red>The tile was not replaced.</font>") else: SaveTile_test2 = ("<font color=green>Passed</font>") else: SaveTile_test2 = ("<font color=red>/save did not return a 200 responce.</font>") except: SaveTile_test1 = ("<font color=red>Failed, there was no " + "response from SaveTile.</font>") else: SaveTile_test1 = ("<font color=red>/save did not return a 200 responce.</font>") SaveTile_test2 = ("<font color=red>Test 2 requires test 1 to succeed.</font>") except: SaveTile_test1 = ("<font color=red>Failed, there was no " + "response from SaveTile.</font>") SaveTile_test2 = ("<font color=red>Test 2 requires test 1 to succeed.</font>") ########################## # UserTileClaimNumber Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() #Check if the system can handle a user who has not been entered yet try: response = self.testapp.get('/howmenytiles') query = UserData.gql("WHERE user = :1", user) thisUserData = query.get() if thisUserData is None: UserTileClaimNumber_test1 = ("<font color=red>The new user information was not created in the database.</font>") else: if thisUserData.Number_Tiles == 0: UserTileClaimNumber_test1 = ("<font color=green>Passed</font>") else: UserTileClaimNumber_test1 = ("<font color=red>UserTileClaimNumber did not create a user information with 0 tiles claimed.</font>") except: UserTileClaimNumber_test1 = ("<font color=red>Failed, there was no response from UserTileClaimNumber.</font>") #Reinitializes the fake datastore for the next test self.testbed.init_datastore_v3_stub() #Assure data about users is retrieved correctly day_time = datetime.today() - timedelta(1) UserData(user=user, lastemail=day_time, Number_Tiles=6).put() try: response = self.testapp.get('/howmenytiles') try: #Check if the correct number of tiles information was contianed in the resoponce response.mustcontain(6) UserTileClaimNumber_test2 = ("<font color=green>Passed</font>") except: UserTileClaimNumber_test2 = ("<font color=red>The correct number of tiles was not returned.</font>") except: UserTileClaimNumber_test2 = ("<font color=red>Failed, there was no response from UserTileClaimNumber.</font>") ########################## # CreateClaim Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() params = {'x': 0, 'y': 0} day_time = datetime.today() - timedelta(1) UserData(user=user, lastemail=day_time, Number_Tiles=0).put() try: response = self.testapp.post('/claim', params) try: query = Claim.gql("WHERE user = :1", user) thisClaimData = query.get() if thisClaimData is not None: CreateClaim_test1 = ("<font color=green>Passed</font>") query = Claim.gql("WHERE user = :1 AND x=:2 AND y=:3", user, 0, 0) thisClaimData2 = query.get() if thisClaimData2 is not None: CreateClaim_test2 = ("<font color=green>Passed</font>") else: CreateClaim_test2 = ("<font color=red>The correct database claim did not exist.</font>") else: CreateClaim_test1 = ("<font color=red>Failed, no claim created for the given user.</font>") CreateClaim_test2 = ("<font color=red>Test1 must succeed for test 2 to run.</font>") except: CreateClaim_test1 = ("<font color=red>Failed, database error.</font>") CreateClaim_test2 = ("<font color=red>Test1 must succeed for test 2 to run.</font>") except: CreateClaim_test1 = ("<font color=red>Failed, there was no response from CreateClaim.</font>") CreateClaim_test2 = ("<font color=red>Test1 must succeed for test 2 to run.</font>") ########################## # InformClaimOwner Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() #For this test we need to check if we are sending mail. self.testbed.init_mail_stub() self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME) params = {'x': 0, 'y': 0} #Create a fake user with 1 tile claimed day_time = datetime.today() - timedelta(1) UserData(user=user, lastemail=day_time, Number_Tiles=1).put() Claim(user=user, x=0, y=0).put() try: response = self.testapp.post('/informclaim', params) messages = self.mail_stub.get_sent_messages(to=user.email()) if len(messages) == 1: InformClaimOwner_test1 = ("<font color=green>Passed</font>") try: response = self.testapp.post('/informclaim', params) messages = self.mail_stub.get_sent_messages(to=user.email()) if len(messages) == 1: InformClaimOwner_test2 = ("<font color=green>Passed</font>") else: InformClaimOwner_test2 = ("<font color=red>Failed, a second message was sent on the same day.</font>") except: InformClaimOwner_test2 = ("<font color=red>Failed, there was no response from InformClaimOwner.</font>") else: InformClaimOwner_test1 = ("<font color=red>Failed, the informing email was not sent to the target user.</font>") InformClaimOwner_test2 = ("<font color=red>Test 2 requires test 1 to succeed.</font>") except: InformClaimOwner_test1 = ("<font color=red>Failed, there was no response from InformClaimOwner.</font>") InformClaimOwner_test2 = ("<font color=red>Test 2 requires test 1 to succeed.</font>") ########################## # RemoveClaim Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() params = {'x': 0, 'y': 0} #Create a fake user with 1 tile claimed day_time = datetime.today() - timedelta(1) UserData(user=user, lastemail=day_time, Number_Tiles=1).put() Claim(user=user, x=0, y=0).put() try: response = self.testapp.post('/unclaim', params) query = Claim.gql("WHERE user = :1 AND x=:2 AND y=:3", user, 0, 0) thisClaimData = query.get() if thisClaimData is None: RemoveClaim_test1 = ("<font color=green>Passed</font>") else: RemoveClaim_test1 = ("<font color=red> The claim was not removed.</font>") except: RemoveClaim_test1 = ("<font color=red>Failed, there was no response from RemoveClaim.</font>") try: query = UserData.gql("WHERE user = :1", user) thisUserData = query.get() if thisUserData.Number_Tiles == 0: RemoveClaim_test2 = ("<font color=green>Passed</font>") else: RemoveClaim_test2 = ("<font color=red>Failed, The user's Number_Tiles was not decremented correctly.</font>") except: RemoveClaim_test2 = ("<font color=red>Failed, there was no response from the mock database.</font>") ########################## # TileClaimedByUser Unit Testing ########################## #Reinitializes the fake blobstore and datastore for the next test self.testbed.init_blobstore_stub() self.testbed.init_datastore_v3_stub() params = {'x': 0, 'y': 0} #Create a fake user with 1 tile claimed day_time = datetime.today() - timedelta(1) UserData(user=user, lastemail=day_time, Number_Tiles=1).put() Claim(user=user, x=0, y=0).put() try: response = self.testapp.get('/hasclaimontile', params) try: response.mustcontain(1) TileClaimedByUser_test1 = ("<font color=green>Passed</font>") except: TileClaimedByUser_test1 = ("<font color=red>Failed, did not detect user's claim.</font>") except: TileClaimedByUser_test1 = ("<font color=red>Failed, there was no response from TileClaimedByUser.</font>") params = {'x': 1, 'y': 0} try: response = self.testapp.get('/hasclaimontile', params) try: response.mustcontain(0) TileClaimedByUser_test2 = ("<font color=green>Passed</font>") except: TileClaimedByUser_test2 = ("<font color=red>Failed, did not detect user's claim.</font>") except: TileClaimedByUser_test2 = ("<font color=red>Failed, there was no response from TileClaimedByUser.</font>") #Swaps the real systems back in, #and deactivates the fake testing system. self.testbed.deactivate() template = jinja_environment.get_template('PYUnitTest.html') self.response.out.write(template.render( MainPage_test1=MainPage_test1, MainPage_test2=MainPage_test2, MainPage_test3=MainPage_test3, MainPage_test4=MainPage_test4, MainPage_test5=MainPage_test5, GetTile_test1=GetTile_test1, GetTile_test2=GetTile_test2, GetTile_test3=GetTile_test3, GetTile_test4=GetTile_test4, SaveTile_test1=SaveTile_test1, SaveTile_test2=SaveTile_test2, UserTileClaimNumber_test1=UserTileClaimNumber_test1, UserTileClaimNumber_test2=UserTileClaimNumber_test2, CreateClaim_test1=CreateClaim_test1, CreateClaim_test2=CreateClaim_test2, InformClaimOwner_test1=InformClaimOwner_test1, InformClaimOwner_test2=InformClaimOwner_test2, RemoveClaim_test1=RemoveClaim_test1, RemoveClaim_test2=RemoveClaim_test2, TileClaimedByUser_test1=TileClaimedByUser_test1, TileClaimedByUser_test2=TileClaimedByUser_test2 )) else: #If not, show login button template = jinja_environment.get_template('PYUnitTestLogin.html') self.response.out.write(template.render())
def post(self): """ Saves the image sent via JSON in the blobstore. If an entry for (x, y) is not in the Tile table of the datastore, create it with the blob key for the image. Otherwise update the entry with the new blob key and delete the existing associated blob. Send messages to any open channel that a change has been made to the tile. Delete any channels that may have been open for more than two hours. """ #Get JSON data x = int(self.request.get('x')) y = int(self.request.get('y')) data = self.request.get('data') #base64 decode image data = base64.b64decode(data) #Write image to blobstore file_name = files.blobstore.create(mime_type='image/png') with files.open(file_name, 'a') as f: f.write(data) files.finalize(file_name) #Get blob key for newly created blob in blobstore blob_key = files.blobstore.get_blob_key(file_name) # Check if tile is already in database query = Tile.gql("WHERE x = :1 AND y = :2", x, y) myTile = query.get() if myTile is None: #Create new tile entry in database with key to new blob myTile = Tile(x=x, y=y, blob_key=blob_key, rand_num=random.random()) myTile.put() else: #Update the blob key in the entry for this tile old_key = myTile.blob_key myTile.blob_key = blob_key myTile.put() #Delete the blob previously associated with the tile google.appengine.ext.blobstore.delete(old_key) #For live updates: #Send a message to the channels indicating this tile has changed. channels = UpdateChannel.gql("").fetch(100) message = json.dumps({"x": x, "y": y, "Type": "Tile"}) for ch in channels: ch_id = ch.channel_id #if a channel is two hours old, delete it. d = parse_datetime(ch_id.split(",")[0]) if d < datetime.now() + timedelta(hours=-2): ch.key.delete() elif ch_id != self.session.get("channel_id"): channel.send_message(ch.channel_id, message) #No response data to send. self.response.set_status(200)