def edit_ipv6(self):
''' Add ipv6 addresses to a box (sorta edits the box object) '''
form = Form(box_uuid="Select a box", ipv6="Please provide a list of IPv6 addresses")
if form.validate(self.request.arguments):
errors = []
box = Box.by_uuid(self.get_argument('box_uuid'))
if box is not None:
ips_string = self.get_argument('ipv6').replace('\n', ',').lower()
ips = filter(lambda char: char in "1234567890abcdef:,", ips_string).split(",")
for ip in filter(lambda ip: 0 < len(ip), ips):
try:
box = Box.by_ip_address(ip)
if box is None:
addr = IpAddress(box_id=box.id, v6=ip)
dbsession.add(addr)
else:
errors.append(
"%s has already been assigned to %s." % (ip, box.name,)
)
except ValueError:
errors.append(
"'%s' is not a valid IPv6 address" % str(ip[:39])
)
dbsession.flush()
else:
errors.append("Box does not exist")
self.render("admin/view/game_objects.html", errors=errors)
else:
self.render("admin/view/game_objects.html", errors=form.errors)
def test_combine_envelope_contents(self):
# Make some pages.
p1 = Page()
p1.save()
p2 = Page()
p2.save()
p3 = Page()
p3.save()
p4 = Page()
p4.save()
# Make a box for them.
b = Box()
b.save()
# Put them in the box.
box.add_content( (p1, p2, p3, p4) )
# Make two envelopes and put pages in them.
e1 = Envelope()
e1.add_content( (p1, p2) )
e2 = Envelope()
e2.add_content( (p3, p4) )
# Combine envelope contents.
e2.send_contents_to_envelope(e1)
self.assertEqual(len(e2.contents.all()), 0,
"Some content is still left in sending envelope.")
self.assertEqual(len(e1.contents.all()), 4,
"Content in receiving envelope is not correct.")
for page in [p1, p2, p3, p4]:
self.assertTrue(page in e1.get_content(),
"Page not found in receiving envelope.")
def test_move_contents_together(self):
# Make some test pages.
p1 = Page()
p1.title = 'Test Page 1'
p1.save()
p2 = Page()
p2.title = 'Test Page 2'
p2.save()
# Make two test boxes.
b1 = Box()
b1.save()
b2 = Box()
b2.save()
# Put two pages in box 1.
b1.add_content( (p1, p2) )
# Put two pages in the same box into an envelope.
e.add_content( (p1, p2) )
# Move the envelope to box 2.
e.move_to_box(b2)
self.assertFalse(b1.contains_content(p1), "Page 1 did not leave box 1.")
self.assertFalse(b1.contains_content(p2), "Page 2 did not leave box 1.")
self.assertTrue(b2.contains_content(p1), "Page 1 did not move to box 2.")
self.assertTrue(b2.contains_content(p2), "Page 2 did not move to box 2.")
def process_request(self, request):
""" This function sets up the user object
Depending on the value of require_login, it
can return None as 'profile'.
"""
#Get Google user_id
google_user = users.get_current_user()
account = None
is_admin = False
logging.info(request.META['HTTP_USER_AGENT'])
if google_user:
#Check if the user already has a site profile
user_id = google_user.user_id()
is_admin = users.is_current_user_admin()
q = Account.all()
q.filter('google_user ='******'My Box')
box.put()
request.user = account
Account.current_user_account = account
request.user_is_admin = is_admin
def edit_ipv6(self):
''' Add ipv6 addresses to a box (sorta edits the box object) '''
form = Form(box_uuid="Select a box",
ipv6="Please provide a list of IPv6 addresses")
if form.validate(self.request.arguments):
errors = []
box = Box.by_uuid(self.get_argument('box_uuid'))
if box is not None:
ips_string = self.get_argument('ipv6').replace('\n',
',').lower()
ips = filter(lambda char: char in "1234567890abcdef:,",
ips_string).split(",")
for ip in filter(lambda ip: 0 < len(ip), ips):
try:
box = Box.by_ip_address(ip)
if box is None:
addr = IpAddress(box_id=box.id, v6=ip)
dbsession.add(addr)
else:
errors.append(
"%s has already been assigned to %s." % (
ip,
box.name,
))
except ValueError:
errors.append("'%s' is not a valid IPv6 address" %
str(ip[:39]))
dbsession.flush()
else:
errors.append("Box does not exist")
self.render("admin/view/game_objects.html", errors=errors)
else:
self.render("admin/view/game_objects.html", errors=form.errors)
def addbox(request):
request.session.set_expiry(0)
box = Box()
location_id = request.POST['sel2']
box.Location = Location.objects.get(id = location_id)
box.save()
return redirect('admin')
def edit_boxes(self):
''' Edit existing boxes in the database '''
form = Form(
uuid="Object not selected",
name="Missing box name",
corporation_uuid="Please select a corporation",
description="Please enter a description",
difficulty="Please enter a difficulty",
)
if form.validate(self.request.arguments):
box = Box.by_uuid(self.get_argument('uuid'))
if box is not None:
errors = []
if self.get_argument('name') != box.name:
if Box.by_name(self.get_argument('name')) is None:
logging.info("Updated box name %s -> %s" % (
box.name,
self.get_argument('name'),
))
box.name = unicode(self.get_argument('name'))
else:
errors.append("Box name already exists")
corp = Corporation.by_uuid(
self.get_argument('corporation_uuid'))
if corp is not None and corp.id != box.corporation_id:
logging.info("Updated %s's corporation %s -> %s" % (
box.name,
box.corporation_id,
corp.id,
))
box.corporation_id = corp.id
elif corp is None:
errors.append("Corporation does not exist")
if self.get_argument('description') != box.description:
logging.info("Updated %s's description %s -> %s" % (
box.name,
box.description,
self.get_argument('description'),
))
box.description = unicode(self.get_argument('description'))
if self.get_argument('difficulty') != box.difficulty:
logging.info("Updated %s's difficulty %s -> %s" % (
box.name,
box.difficulty,
self.get_argument('difficulty'),
))
box.difficulty = unicode(self.get_argument('difficulty'))
dbsession.add(box)
dbsession.flush()
self.render("admin/view/game_objects.html", errors=errors)
else:
self.render("admin/view/game_objects.html",
errors=["Box does not exist"])
else:
self.render("admin/view/game_objects.html", errors=form.errors)
def test_edit_get_objet(self):
view = EditSuggestionView()
request = RequestFactory()
view.request = request
self.moxx.StubOutWithMock(views, 'get_client_ip')
views.get_client_ip(request).AndReturn(self.ip)
self.moxx.StubOutWithMock(Box, 'get_unread')
Box.get_unread(self.ip).AndReturn(Suggestion(ip_address=self.ip))
self.moxx.ReplayAll()
view.get_object()
self.moxx.VerifyAll()
def test_box_descriptor(self):
b = Box()
self.assertTrue(b.descriptor is None, "Descriptor not initialized to None.")
p = Page()
p.title = 'Testbox 1'
p.data = 'This Page is used as the descriptor for Testbox 1.'
p.save()
b.descriptor = p
b.save()
self.assertTrue(b.descriptor == p, "Descriptor not saved.")
self.assertTrue(p.describes_box == b, "Descriptor does not point back to box.")
def create_box(self):
''' Create a box object '''
form = Form(
box_name="Enter a box name",
description="Enter a description",
difficulty="Select a difficulty",
corporation_uuid="Please select a corporation",
game_level="Please select a game level",
)
if form.validate(self.request.arguments):
try:
game_level = int(self.get_argument('game_level'))
corp_uuid = self.get_argument('corporation_uuid')
if Box.by_name(self.get_argument('box_name')) is not None:
self.render("admin/create/box.html",
errors=["Box name already exists"]
)
elif Corporation.by_uuid(corp_uuid) is None:
self.render("admin/create/box.html",
errors=["Corporation does not exist"]
)
elif GameLevel.by_number(game_level) is None:
self.render("admin/create/box.html",
errors=["Game level does not exist"]
)
else:
self.__mkbox__()
self.redirect('/admin/view/game_objects')
except ValueError:
self.render('admin/view/create.html',
errors=["Invalid level number"]
)
else:
self.render("admin/create/box.html", errors=form.errors)
def savePaths(request, paths, strokeWidth, strokeColor, object_type, fillColor=None):
# if not request.user.is_authenticated():
# return simplejson.dumps({'state': 'not_logged_in'})
print "hih"
print request.user.username
pIDs = []
pks = []
for path in paths:
pID = path['pID']
points = path['points']
planet = str(path['planet']['x'])+','+str(path['planet']['y'])
lockedAreas = Box.objects(planet=planet, box__geo_intersects={"type": "LineString", "coordinates": points } )
if lockedAreas.count()>0:
return simplejson.dumps( {'state': 'error', 'message': 'Your drawing intersects with a locked area'} )
p = Path(planet=planet, points=points, owner=request.user.username, strokeColor=strokeColor, fillColor=fillColor, strokeWidth=strokeWidth, object_type=object_type, pID=pID )
p.save()
pIDs.append(pID)
pks.append(p.pk)
return simplejson.dumps( {'state': 'success', 'pIDs': pIDs, 'pk': pks} )
def create_flag(self):
''' Create a flag '''
form = Form(
box_uuid="Please select a box",
flag_name="Please enter a name",
token="Please enter a token value",
reward="Please enter a reward value",
is_file="Please select a file setting",
description="Please enter a flag description",
)
if form.validate(self.request.arguments):
try:
if Flag.by_name(self.get_argument('flag_name')) is not None:
self.render('admin/create/flag.html',
errors=["Name already exists"])
elif Flag.by_token(self.get_argument('token')) is not None:
self.render('admin/create/flag.html',
errors=["Token value is not unique"])
elif Box.by_uuid(self.get_argument('box_uuid')) is None:
self.render('admin/create/flag.html',
errors=["Box does not exist"])
else:
reward = int(self.get_argument('reward', 'NaN'))
self.__mkflag__(reward)
self.redirect('/admin/view/game_objects')
except ValueError:
self.render('admin/create/flag.html',
errors=["Invalid reward value"])
else:
self.render("admin/create/flag.html", errors=form.errors)
def create_box(self):
''' Create a box object '''
form = Form(
box_name="Enter a box name",
description="Enter a description",
difficulty="Select a difficulty",
corporation_uuid="Please select a corporation",
game_level="Please select a game level",
)
if form.validate(self.request.arguments):
try:
game_level = int(self.get_argument('game_level'))
corp_uuid = self.get_argument('corporation_uuid')
if Box.by_name(self.get_argument('box_name')) is not None:
self.render("admin/create/box.html",
errors=["Box name already exists"])
elif Corporation.by_uuid(corp_uuid) is None:
self.render("admin/create/box.html",
errors=["Corporation does not exist"])
elif GameLevel.by_number(game_level) is None:
self.render("admin/create/box.html",
errors=["Game level does not exist"])
else:
self.__mkbox__()
self.redirect('/admin/view/game_objects')
except ValueError:
self.render('admin/view/create.html',
errors=["Invalid level number"])
else:
self.render("admin/create/box.html", errors=form.errors)
def create_my_pokemon():
data = request.get_json()
rec = Box(pid=data["pid"], name=data["name"], id=current_identity.id)
db.session.add(rec)
db.session.commit()
return data[
"name"] + " captured", 201 # return data and set the status code
def add_source_code(self):
form = Form(
box_uuid="Please select a box",
price="Please input a price for the source code",
description="Please enter a description",
)
if form.validate(self.request.arguments):
box = Box.by_uuid(self.get_argument('box_uuid'))
if box is not None:
if not 'source_archive' in self.request.files and 0 < len(
self.request.files['source_archive']):
self.render('admin/upgrades/source_code_market.html',
errors=["No file data"])
else:
try:
price = abs(int(self.get_argument('price', 'NaN')))
self.create_source_code(box, price)
self.render('admin/upgrades/source_code_market.html',
errors=None)
except ValueError:
self.render('admin/upgrades/source_code_market.html',
errors=["Price must be an integer"])
else:
self.render('admin/upgrades/source_code_market.html',
errors=["The selected box does not exist"])
else:
self.render('admin/upgrades/source_code_market.html',
errors=form.errors)
def create_flag(self):
''' Create a flag '''
form = Form(
box_uuid="Please select a box",
flag_name="Please enter a name",
token="Please enter a token value",
reward="Please enter a reward value",
is_file="Please select a file setting",
description="Please enter a flag description",
)
if form.validate(self.request.arguments):
try:
if Flag.by_name(self.get_argument('flag_name')) is not None:
self.render('admin/create/flag.html',
errors=["Name already exists"]
)
elif Flag.by_token(self.get_argument('token')) is not None:
self.render('admin/create/flag.html',
errors=["Token value is not unique"]
)
elif Box.by_uuid(self.get_argument('box_uuid')) is None:
self.render('admin/create/flag.html',
errors=["Box does not exist"]
)
else:
reward = int(self.get_argument('reward', 'NaN'))
self.__mkflag__(reward)
self.redirect('/admin/view/game_objects')
except ValueError:
self.render('admin/create/flag.html',
errors=["Invalid reward value"]
)
else:
self.render("admin/create/flag.html", errors=form.errors)
def scoring_round():
''' Multi-threaded scoring '''
boxes = list(Box.get_all())
logging.info("Starting scoring round with %d boxes" % len(boxes))
for box in boxes:
score_box(box)
logging.info("Scoring round completed")
def render_page(self, errors=None):
''' Addes extra params to render() '''
user = self.get_current_user()
boxes = filter(lambda box: box.source_code is not None, Box.all())
self.render('upgrades/source_code_market.html',
user=user, boxes=boxes, errors=errors
)
def add_source_code(self):
form = Form(
box_uuid="Please select a box",
price="Please input a price for the source code",
description="Please enter a description",
)
if form.validate(self.request.arguments):
box = Box.by_uuid(self.get_argument('box_uuid'))
if box is not None:
if not 'source_archive' in self.request.files and 0 < len(self.request.files['source_archive']):
self.render('admin/upgrades/source_code_market.html',
errors=["No file data"]
)
else:
try:
price = abs(int(self.get_argument('price', 'NaN')))
self.create_source_code(box, price)
self.render('admin/upgrades/source_code_market.html',
errors=None
)
except ValueError:
self.render('admin/upgrades/source_code_market.html',
errors=["Price must be an integer"]
)
else:
self.render('admin/upgrades/source_code_market.html',
errors=["The selected box does not exist"]
)
else:
self.render('admin/upgrades/source_code_market.html',
errors=form.errors
)
def edit_boxes(self):
''' Edit existing boxes in the database '''
form = Form(
uuid="Object not selected",
name="Missing box name",
corporation_uuid="Please select a corporation",
description="Please enter a description",
difficulty="Please enter a difficulty",
)
if form.validate(self.request.arguments):
box = Box.by_uuid(self.get_argument('uuid'))
if box is not None:
errors = []
if self.get_argument('name') != box.name:
if Box.by_name(self.get_argument('name')) is None:
logging.info("Updated box name %s -> %s" %
(box.name, self.get_argument('name'),)
)
box.name = unicode(self.get_argument('name'))
else:
errors.append("Box name already exists")
corp = Corporation.by_uuid(self.get_argument('corporation_uuid'))
if corp is not None and corp.id != box.corporation_id:
logging.info("Updated %s's corporation %s -> %s" %
(box.name, box.corporation_id, corp.id,))
box.corporation_id = corp.id
elif corp is None:
errors.append("Corporation does not exist")
if self.get_argument('description') != box.description:
logging.info("Updated %s's description %s -> %s" %
(box.name, box.description, self.get_argument('description'),)
)
box.description = unicode(self.get_argument('description'))
if self.get_argument('difficulty') != box.difficulty:
logging.info("Updated %s's difficulty %s -> %s" %
(box.name, box.difficulty, self.get_argument('difficulty'),)
)
box.difficulty = unicode(self.get_argument('difficulty'))
dbsession.add(box)
dbsession.flush()
self.render("admin/view/game_objects.html", errors=errors)
else:
self.render("admin/view/game_objects.html",
errors=["Box does not exist"]
)
else:
self.render("admin/view/game_objects.html", errors=form.errors)
def test_box_timeline(self):
if not settings.BOX_USES_TIMELINE: return
# What is the latest time, before we start?
start = self._get_latest_time()
# @ Time 1: Create empty box.
b = Box()
b.save()
box_created = self._get_latest_time()
self.assertTrue( (box_created > start),
"Timeline not advanced on box creation." )
# @ Time 2: Add pages to box.
b.add_content( [p1, p2] )
pages_added = self._get_latest_time()
self.assertTrue( (pages_added > box_created),
"Timeline not advanced on content addition." )
# @ Time 4: Remove page 1 from box.
b.remove_content(p1)
page_removed = self._get_latest_time()
self.assertTrue( (page_removed > pages_added),
"Timeline not advanced on content removal." )
# Verify that box contains one page at the present time.
self.assertEqual(len(b.contents.all()), 1,
"Box contents at present time not correct.")
# View box pages @ time 2 again.
way_back_when = b.contents.filter(added__lte=pages_added,
removed__gt=pages_added)
self.assertEqual(len(way_back_when), 2,
"Box contents at prior time not correct.")
def open(self):
''' When we receive a new websocket connect '''
box = Box.by_ip_address(self.request.remote_ip)
if box is not None:
self.box = box
self.remote_ip = self.request.remote_ip
self.write_message("box ok")
else:
self.close()
def open(self):
''' When we receive a new websocket connect '''
box = Box.by_ip_address(self.request.remote_ip)
if box is not None:
self.box = box
self.remote_ip = self.request.remote_ip
self.write_message("box ok")
else:
self.close()
def render_page(self, flag, errors=[]):
''' Wrapper to .render() to avoid duplicate code '''
user = self.get_current_user()
box = Box.by_id(flag.box_id)
self.render('missions/box.html',
box=box,
team=user.team,
errors=errors,
)
def render_page(self, flag, errors=[]):
''' Wrapper to .render() to avoid duplicate code '''
user = self.get_current_user()
box = Box.by_id(flag.box_id)
self.render(
'missions/box.html',
box=box,
team=user.team,
errors=errors,
)
def scoring_round():
'''
Executed as a periodic callback for main io_loop: Iterates of all the boxes
and scores each box.
'''
boxes = list(Box.all())
logging.info("Starting scoring round with %d boxes" % len(boxes))
for box in boxes:
score_box(box)
logging.info("Scoring round completed")
def handle_mouse(self, e, x, y, flags, param):
if self.mode == 'set_middle':
if e == cv2.EVENT_LBUTTONDOWN:
self.platform_middle = (x, y)
self.mode = None
else:
if e == cv2.EVENT_LBUTTONDOWN:
self.area = Box(x, y, None, None)
elif e == cv2.EVENT_LBUTTONUP:
self.area.x2 = x
self.area.y2 = y
def open(self, *args):
""" Steps 1 and 2; called when a new bot connects """
box = Box.by_ip_address(self.request.remote_ip)
self.remote_ip = self.request.remote_ip
if box is None and self.config.whitelist_box_ips:
logging.debug("Rejected bot from '%s' (not a box)" % self.request.remote_ip)
self.write_message({"opcode": "error", "message": "Invalid IP address."})
self.close()
else:
logging.debug("Interrogating bot on %s" % self.request.remote_ip)
self.write_message({"opcode": "interrogate", "xid": self.xid})
def to_dict(self):
''' Returns public data as a dict '''
box = Box.by_id(self.box_id)
return {
'name': self.name,
'uuid': self.uuid,
'token': self.token,
'description': self.description,
'value': self.value,
'box': box.uuid,
}
def to_dict(self):
''' Returns public data as a dict '''
box = Box.by_id(self.box_id)
return {
'name': self.name,
'uuid': self.uuid,
'description': self.description,
'value': self.value,
'box': box.uuid,
'token': self.token,
}
def server_box_icon(self):
ID = self.request.get('ID')
if ID:
box = Box.get_by_urlsafe_key(ID)
if box:
self.response.headers['Content-Type'] = 'image/png'
self.response.out.write(box.icon)
return
self.error(404)
def open(self, *args):
""" Steps 1 and 2; called when a new bot connects """
box = Box.by_ip_address(self.request.remote_ip)
self.remote_ip = self.request.remote_ip
if box is None and self.config.whitelist_box_ips:
logging.debug("Rejected bot from '%s' (not a box)" % self.request.remote_ip)
self.write_message({"opcode": "error", "message": "Invalid IP address."})
self.close()
else:
logging.debug("Interrogating bot on %s" % self.request.remote_ip)
self.write_message({"opcode": "interrogate", "xid": self.xid})
def get_box(self, request):
'''
Retrieve a single box for a specific product and user
'''
# fetch the product and user based on the request
box = Box.get_by_urlsafe_key(request.boxKey)
if not box:
message = 'No box with the key "%s" exists.' % request.boxKey
raise endpoints.NotFoundException(message)
return BoxHelper.create_box(box)
def convert_to_db(paths, job, label):
paths = clean_paths(paths)
paths_db = []
for path in paths:
path_db = Path(job=job, label=label)
for box in path:
box_db = Box(path=path_db)
box_db.xtl = box['rect'][0]
box_db.ytl = box['rect'][1]
box_db.xbr = box['rect'][0] + box['rect'][2]
box_db.ybr = box['rect'][1] + box['rect'][3]
box_db.frame = box['frame']
box_db.outside = 0 if box['visible'] else 1
box_db.occluded = 0
path_db.boxes.append(box_db)
paths_db.append(path_db)
return paths_db
def __mkbox__(self):
''' Creates a box in the database '''
corp = Corporation.by_uuid(self.get_argument('corporation_uuid'))
level = GameLevel.by_number(int(self.get_argument('game_level')))
box = Box(
name=unicode(self.get_argument('box_name')),
description=unicode(self.get_argument('description')),
difficulty=unicode(self.get_argument('difficulty')),
corporation_id=corp.id,
game_level_id=level.id,
)
dbsession.add(box)
dbsession.flush()
def __mkflag__(self, reward):
''' Creates a flag in the database '''
box = Box.by_uuid(self.get_argument('box_uuid'))
flag = Flag(
name=unicode(self.get_argument('flag_name')),
token=unicode(self.get_argument('token')),
description=unicode(self.get_argument('description')),
is_file=bool(self.get_argument('is_file', 'false') == 'true'),
box_id=box.id,
value=reward,
)
dbsession.add(flag)
dbsession.flush()
def __mkflag__(self, reward):
''' Creates a flag in the database '''
box = Box.by_uuid(self.get_argument('box_uuid'))
flag = Flag(
name=unicode(self.get_argument('flag_name')),
token=unicode(self.get_argument('token')),
description=unicode(self.get_argument('description')),
is_file=bool(self.get_argument('is_file', 'false') == 'true'),
box_id=box.id,
value=reward,
)
dbsession.add(flag)
dbsession.flush()
def get(self, *args, **kwargs):
''' Renders the box details page '''
uuid = self.get_argument('uuid', '')
box = Box.by_uuid(uuid)
if box is not None:
user = self.get_current_user()
self.render('missions/box.html',
box=box,
team=user.team,
errors=[],
)
else:
self.render('public/404.html')
def post(self, *args, **kwargs):
''' Purchase a hint '''
uuid = self.get_argument('uuid', '')
hint = Hint.by_uuid(uuid)
box = Box.by_id(hint.box_id)
if hint is not None:
user = self.get_current_user()
if hint.price <= user.team.money:
self._purchase_hint(hint, user.team)
self.render_page(box)
else:
self.render_page(box, ["You cannot afford to purchase this hint."])
else:
self.render_page(box, ["Hint does not exist."])
def open(self, *args):
''' Steps 1 and 2; called when a new bot connects '''
box = Box.by_ip_address(self.request.remote_ip)
self.remote_ip = self.request.remote_ip
if box is None and self.config.whitelist_box_ips:
logging.debug("Rejected bot from '%s' (not a box)" % self.request.remote_ip)
self.write_message({
'opcode': 'error',
'message': 'Invalid IP address.'
})
self.close()
else:
logging.debug("Interrogating bot on %s" % self.request.remote_ip)
self.write_message({'opcode': 'interrogate', 'xid': self.xid})
def open(self, *args):
''' Steps 1 and 2; called when a new bot connects '''
box = Box.by_ip_address(self.request.remote_ip)
self.remote_ip = self.request.remote_ip
if box is None and self.config.whitelist_box_ips:
logging.debug("Rejected bot from '%s' (not a box)" % self.request.remote_ip)
self.write_message({
'opcode': 'error',
'message': 'Invalid IP address.'
})
self.close()
else:
logging.debug("Interrogating bot on %s" % self.request.remote_ip)
self.write_message({'opcode': 'interrogate', 'xid': self.xid})
def get(self, *args, **kwargs):
''' Renders the box details page '''
uuid = self.get_argument('uuid', '')
box = Box.by_uuid(uuid)
if box is not None:
user = self.get_current_user()
self.render(
'missions/box.html',
box=box,
team=user.team,
errors=[],
)
else:
self.render('public/404.html')
def create_box(name, corporation, difficulty, game_level, description,
ipv4_addresses=[], ipv6_addresses=[], avatar=None):
if Box.by_name(name) is not None:
logging.info("Box with name '%s' already exists, skipping" % (name))
return Box.by_name(name)
logging.info("Create Box: %s" % name)
if isinstance(game_level, int):
game_level = GameLevel.by_number(game_level)
box = Box(
name=unicode(name[:16]),
corporation_id=corporation.id,
difficulty=unicode(difficulty[:16]),
game_level_id=game_level.id,
_description=unicode(description[:1024]),
)
dbsession.add(box)
dbsession.flush()
if avatar is not None and os.path.exists(avatar):
set_avatar(box, avatar)
for ip_address in ipv4_addresses:
__mkipv4__(box, ip_address)
for ip_address in ipv6_addresses:
__mkipv6__(box, ip_address)
return box
def post(self, *args, **kwargs):
form = Form(box_uuid="Please select leaked code to buy")
if form.validate(self.request.arguments):
box = Box.by_uuid(self.get_argument('box_uuid', ''))
if box is not None and box.source_code is not None:
user = self.get_current_user()
if box.source_code.price <= user.team.money:
self.purchase_code(box)
self.redirect("/source_code_market")
else:
self.render_page(["You cannot afford to purchase this code"])
else:
self.render_page(["Box does not exist"])
else:
self.render_page(form.errors)
def post(self, *args, **kwargs):
''' Purchase a hint '''
uuid = self.get_argument('uuid', '')
hint = Hint.by_uuid(uuid)
box = Box.by_id(hint.box_id)
if hint is not None:
user = self.get_current_user()
if hint.price <= user.team.money:
self._purchase_hint(hint, user.team)
self.render_page(box)
else:
self.render_page(box,
["You cannot afford to purchase this hint."])
else:
self.render_page(box, ["Hint does not exist."])
def convert_to_db(paths, job, label):
paths = clean_paths(paths)
paths_db = []
for path in paths:
path_db = Path(job = job, label=label)
for box in path:
box_db = Box(path = path_db)
box_db.xtl = box['rect'][0]
box_db.ytl = box['rect'][1]
box_db.xbr = box['rect'][0] + box['rect'][2]
box_db.ybr = box['rect'][1] + box['rect'][3]
box_db.frame = box['frame']
box_db.outside = 0 if box['visible'] else 1
box_db.occluded = 0
path_db.boxes.append(box_db)
paths_db.append(path_db)
return paths_db
def open(self, *args):
''' When we receive a new websocket connect '''
box = Box.by_ip_address(self.request.remote_ip)
if box is not None:
self.box_uuid = box.uuid
self.box_name = box.name
self.remote_ip = self.request.remote_ip
self.write_message({
'opcode': 'get_user',
})
else:
logging.debug("Rejected bot from '%s' (not a box)" % self.request.remote_ip)
self.write_message({
'opcode': 'error',
'message': 'Invalid IP address.'
})
self.close()
def create_box(name, corporation, difficulty, game_level, description,
ipv4_addresses=[], ipv6_addresses=[]):
print(INFO + "Create Box: " + bold + name + W)
box = Box(
name=unicode(name),
corporation_id=corporation.id,
difficulty=unicode(difficulty),
game_level_id=game_level.id,
description=unicode(description),
)
dbsession.add(box)
dbsession.flush()
for ip_address in ipv4_addresses:
__mkipv4__(box, ip_address)
for ip_address in ipv6_addresses:
__mkipv6__(box, ip_address)
return box
def post(self, *args, **kwargs):
''' Purchase a hint '''
uuid = self.get_argument('uuid', '')
hint = Hint.by_uuid(uuid)
box = Box.by_id(hint.box_id)
if hint is not None:
user = self.get_current_user()
if hint.price <= user.team.money:
logging.info("%s (%s) purchased a hint for $%d on %s" % (
user.handle, user.team.name, hint.price, box.name
))
self._purchase_hint(hint, user.team)
self.render_page(box)
else:
self.render_page(box, ["You cannot afford to purchase this hint."])
else:
self.render_page(box, ["Hint does not exist."])
def dict_to_db(data_dict, title, index_to_id):
"""Enters the data into the MongoDB.
Args:
* data_dict: dict containing annotations for 1 video.
{
'url': <url>,
'tracks': [
{'faces':[
{'time': 0.0, 'box': [1, 2, 3, 4]},
{'time': 1.0, 'box': [2, 3, 4, 5]},
...
],
'annotation': 'Georges Clooney'
}
]
}
* title : string, title of the movie
* index_to_id: dict maps from index in the timecode.txt to entity ID
"""
tracks = []
for track in data_dict['tracks']:
ent_id = index_to_id[int(track['annotation'])]
boxes = []
for box in sorted(track['faces'], key=lambda x: x['time']):
boxes.append(
Box(timestamp=box['time'],
x=box['box'][0],
y=box['box'][1],
w=box['box'][2],
h=box['box'][3]))
tracks.append(
Track(start=boxes[0].timestamp,
end=boxes[-1].timestamp,
boxes=boxes,
entity=ent_id))
# Create the video
vid = Video(title=title, tracks=tracks)
vid.save()
# Get the hash of the URL (minus the protocol)
url = data_dict['url'].split('https://www.')[1]
hasher = hashlib.md5()
hasher.update(url)
hash_md5 = hasher.hexdigest()
SourceVideo(source_url=url, hash=hash_md5, reminiz_video=vid.id).save()
def box_level(self):
''' Changes a boxs level '''
form = Form(box_uuid="No box selected", level_uuid="No level selected")
if form.validate(self.request.arguments):
errors = []
box = Box.by_uuid(self.get_argument('box_uuid'))
level = GameLevel.by_uuid(self.get_argument('level_uuid'))
if box is not None and level is not None:
box.game_level_id = level.id
dbsession.add(box)
dbsession.flush()
elif box is None:
errors.append("Box does not exist")
elif level is None:
errors.append("GameLevel does not exist")
self.render("admin/view/game_levels.html", errors=errors)
else:
self.render("admin/view/game_levels.html", errors=form.errors)
def open(self, *args):
''' When we receive a new websocket connect '''
box = Box.by_ip_address(self.request.remote_ip)
if box is not None:
self.box_uuid = box.uuid
self.box_name = box.name
self.remote_ip = self.request.remote_ip
self.write_message({
'opcode': 'get_user',
})
else:
logging.debug("Rejected bot from '%s' (not a box)" %
self.request.remote_ip)
self.write_message({
'opcode': 'error',
'message': 'Invalid IP address.'
})
self.close()
def box_level(self):
''' Changes a boxs level '''
form = Form(box_uuid="No box selected", level_uuid="No level selected")
if form.validate(self.request.arguments):
errors = []
box = Box.by_uuid(self.get_argument('box_uuid'))
level = GameLevel.by_uuid(self.get_argument('level_uuid'))
if box is not None and level is not None:
box.game_level_id = level.id
dbsession.add(box)
dbsession.flush()
elif box is None:
errors.append("Box does not exist")
elif level is None:
errors.append("GameLevel does not exist")
self.render("admin/view/game_levels.html", errors=errors)
else:
self.render("admin/view/game_levels.html", errors=form.errors)
def interrogation_response(self, msg):
""" Steps 3 and 4; validate repsonses """
logging.debug("Received interrogate response, validating ...")
response_xid = msg["response_xid"]
user = User.by_handle(msg["handle"])
box = Box.by_name(msg["box_name"])
if self.config.whitelist_box_ips and self.remote_ip not in box.ips:
self.send_error("Invalid remote IP for this box")
elif user is None or user.is_admin():
self.send_error("User does not exist")
elif box is None:
self.send_error("Box does not exist")
elif not self.is_valid_xid(box, response_xid):
self.send_error("Invalid xid response")
else:
self.team_name = user.team.name
self.team_uuid = user.team.uuid
self.box_uuid = box.uuid
self.box_name = box.name
self.add_to_botnet(user)
def get(self, *args, **kwargs):
''' Registers a reporting service on a remote box '''
box = Box.by_ip_address(self.request.remote_ip)
if box is not None:
try:
handle = self.get_argument("handle")
user = User.by_handle(handle)
if user is not None:
if not box in user.team.boxes:
user.team.boxes.append(box)
dbsession.add(user.team)
dbsession.flush()
self.write(unicode(user.team.listen_port))
else:
self.write("Invalid handle")
except:
self.write("Missing parameter")
else:
self.write("Invalid ip address")
self.finish()
def interrogation_response(self, msg):
''' Steps 3 and 4; validate repsonses '''
logging.debug("Recieved interrogate response, validating ...")
response_xid = msg['rxid']
user = User.by_handle(msg['handle'])
box = Box.by_name(msg['box_name'])
if self.config.whitelist_box_ips and self.remote_ip not in box.ips:
self.send_error("Invalid remote IP for this box")
elif user is None or user.has_permission(ADMIN_PERMISSION):
self.send_error("User does not exist")
elif box is None:
self.send_error("Box does not exist")
elif not self.is_valid_xid(box, response_xid):
self.send_error("Invalid xid response")
else:
self.team_name = user.team.name
self.team_uuid = user.team.uuid
self.box_uuid = box.uuid
self.box_name = box.name
self.add_to_botnet()
def delete_source_code(self):
''' Delete source code file '''
uuid = self.get_argument('box_uuid', '')
box = Box.by_uuid(uuid)
if box is not None and box.source_code is not None:
source_code_uuid = box.source_code.uuid
dbsession.delete(box.source_code)
dbsession.flush()
root = self.application.settings['source_code_market_dir']
source_code_path = root + '/' + source_code_uuid
logging.info("Delete souce code market file: %s (box: %s)" % (
source_code_path,
box.name,
))
if os.path.exists(source_code_path):
os.unlink(source_code_path)
errors = None
else:
errors = ["Box does not exist, or contains no source code"]
self.render('admin/upgrades/source_code_market.html', errors=errors)