def post(self):
# confirm that the X-Manual header was specified
manual = checkXManual(request)
prevId = -1
if 'X-Crop-Id' in request.headers:
prevId = request.headers.get('X-Crop-Id')
else:
abort(400, "Need to specify header 'X-Crop-Id'!")
dao = OutgoingManualDAO(
defaultConfigPath()) if manual else OutgoingAutonomousDAO(
defaultConfigPath())
outgoingIn = outgoing_manual(
json=request.get_json()) if manual else outgoing_autonomous(
json=request.get_json())
outgoingIn.crop_id = prevId
resultingId = dao.upsertClassification(outgoingIn)
if resultingId == -1:
return {
'message':
'Failed to insert classification into outgoing table'
}, 500
response = make_response(
jsonify({
'message': 'success!',
'id': resultingId
}))
response.headers['X-Class-Id'] = resultingId
return response
def test(self):
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.type = 'standard'
testIns.orientation = 'NE'
testIns.shape = 'star'
testIns.background_color = 'blue'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'purple'
testIns.latitude = 40.11111
testIns.longitude = -111.222222
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
id = dao.addClassification(testIns)
self.assertNotEqual(id, -1)
model = dao.getClassification(id)
self.assertIsNotNone(model)
classOut = dao.submitPendingTarget(model.target)
self.assertIsNotNone(classOut)
imgPath = os.path.dirname(os.path.realpath(__file__)) + '/assets/star.png'
targetOut = submitted_target(outgoingManualOrAutonomous=classOut, autonomous_in=False)
targetOut.crop_path = imgPath
auvsiDao = AuvsiOdlcDao()
auvsiDao.addTarget(targetOut)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
# see how it works on an empty table
self.assertIsNone(dao.submitAllPendingTargets())
# this will insert records for 2 different targets from 3 classifications:
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
dao.addClassification(testIns)
testIns.crop_id = 43
dao.addClassification(testIns)
testIns.crop_id = 44
testIns.alphanumeric = 'C'
testIns.submitted = 'submitted' # this wont work -> it should still be unsubmitted
dao.addClassification(testIns)
result = dao.submitAllPendingTargets()
self.assertIsNotNone(result)
self.assertEqual(len(result), 2) # should have 2 targets
def newModelFromRow(self, row, json=None):
"""
Create a new outgoing_manual model object given a list of sql values from the table,
or a json dictionary
@type row: [string]
@param row: List of ordered string values to be placed within an outgoing_manual object
"""
return outgoing_manual(tableValues=row, json=json)
def test(self):
# insert some targets
dao = OutgoingManualDAO(defaultConfigPath())
truncateTable('outgoing_manual')
# see what it does with an empty table:
self.assertIsNone(dao.submitPendingTarget(1))
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'N'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
self.assertIsNot(dao.addClassification(testIns), -1)
testIns.crop_id = 43
testIns.latitude = 40.222
testIns.longitude = -111.222
testIns.orientation = 'NE'
testIns.background_color = 'orange'
self.assertIsNot(dao.addClassification(testIns), -1)
testIns.crop_id = 44
testIns.latitude = 40.333
testIns.longitude = -111.333
testIns.alphanumeric_color = 'white'
resultingId = dao.addClassification(testIns)
self.assertIsNot(resultingId, -1)
classResult = dao.getClassification(resultingId)
submissionResult = dao.submitPendingTarget(classResult.target)
self.assertAlmostEqual(submissionResult.latitude, 40.222)
self.assertAlmostEqual(submissionResult.longitude, -111.222)
self.assertEqual(submissionResult.orientation, 'NE')
self.assertEqual(submissionResult.background_color, 'orange')
self.assertEqual(submissionResult.alphanumeric_color, 'black')
self.assertEqual(submissionResult.alphanumeric, 'A')
self.assertEqual(submissionResult.shape, 'circle')
# make sure that when we submit another classification that belongs
# to the same target that its submitted state automatically goes to
# 'inherited_submission'
testIns.crop_id = 45
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
classResult = dao.getClassification(resultingId)
self.assertIsNotNone(classResult)
self.assertEqual(classResult.submitted, 'inherited_submission')
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
self.assertNotEqual(dao.addClassification(testIns), -1)
# should now fail to insert a duplicate crop_id
self.assertEqual(dao.addClassification(testIns), -1)
self.assertIsNotNone(dao.getClassificationByUID(42))
def test(self):
truncateTable('cropped_manual')
truncateTable('incoming_image')
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
self.assertNotEqual(dao.addClassification(testIns), -1)
dao = CroppedManualDAO(defaultConfigPath())
model = cropped_manual()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
model.crop_coordinate_br = "(12, 34)"
model.crop_coordinate_tl = "(56, 78)"
self.assertNotEqual(dao.addImage(model), -1)
dao = IncomingImageDAO(defaultConfigPath())
model = incoming_image()
model.time_stamp = 1547453775.2
model.focal_length = 16.0
model.image_path = '/im/a/totally/real/path/i/swear.jpg'
model.manual_tap = True
model.autonomous_tap = False
resultingId = dao.addImage(model)
self.assertNotEqual(resultingId, -1)
util = UtilDAO(defaultConfigPath())
util.resetManualDB()
resultingModel = dao.getImage(resultingId)
self.assertIsNotNone(resultingModel)
self.assertFalse(resultingModel.manual_tap)
self.assertEqual(resultingModel.image_path, model.image_path)
self.assertEqual(resultingModel.focal_length, model.focal_length)
dao = CroppedManualDAO(defaultConfigPath())
self.assertEqual(len(dao.getAll()), 0)
dao = OutgoingManualDAO(defaultConfigPath())
self.assertEqual(len(dao.getAll()), 0)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
insResult = dao.getClassification(resultingId)
self.assertIsNotNone(insResult.target)
self.assertNotEqual(insResult.target, -1)
testIns.crop_id = 43
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
insResult2 = dao.getClassification(resultingId)
self.assertEqual(insResult.target, insResult2.target)
testIns.crop_id = 44
testIns.alphanumeric = 'C'
testIns.submitted = 'submitted' # this wont work -> it should still be unsubmitted
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
insResult3 = dao.getClassification(resultingId)
self.assertNotEqual(insResult3.target, insResult2.target)
# the target id should change on this update
testIns.crop_id = 42
testIns.alphanumeric = 'C'
testIns.submitted = 'unsubmitted'
result = dao.updateClassificationByUID(testIns.crop_id,
testIns.toDict())
self.assertNotEqual(result.class_id, -1)
self.assertEqual(result.target, insResult3.target)
def test(self):
# insert some targets
dao = OutgoingManualDAO(defaultConfigPath())
truncateTable('outgoing_manual')
# make sure if fails when we try and remove on empty table:
deleteResult = dao.removeClassification(100)
self.assertFalse(deleteResult)
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'N'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertIsNot(resultingId, -1)
testIns.crop_id = 44
otherId = dao.addClassification(testIns)
self.assertNotEqual(otherId, -1)
# make sure it doesn't delete everything:
deleteResult = dao.removeClassification(
otherId + 5) # give bogus id that should fail
self.assertFalse(deleteResult)
self.assertEqual(len(dao.getAll()),
2) # make sure there's still 2 records
deleteResult = dao.removeClassification(resultingId)
self.assertTrue(deleteResult)
self.assertEqual(len(dao.getAll()), 1) # should still be 1 record left
self.assertIsNotNone(dao.getClassification(
otherId)) # make sure the otherId wasn't deleted on accident
def test(self):
truncateTable('outgoing_autonomous')
dao = OutgoingAutonomousDAO(defaultConfigPath())
# empty table
self.assertIsNone(dao.getUnlocatedClassifications())
# populate with two classifications that need geo, one that doesnt
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
testIns.crop_id = 43
testIns.background_color = 'orange'
resultingId2 = dao.addClassification(testIns)
self.assertNotEqual(resultingId2, -1)
testIns.crop_id = 44
testIns.latitude = 40.111
testIns.longitude = -111.222
resultingId3 = dao.addClassification(testIns)
self.assertNotEqual(resultingId3, -1)
unlocated = dao.getUnlocatedClassifications()
self.assertIsNotNone(unlocated)
self.assertEqual(len(unlocated), 2)
# the two models in the list should be our first two inserts and have
# crop ids 42 and 43
self.assertLess(unlocated[0].crop_id, 44)
self.assertLess(unlocated[1].crop_id, 44)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
# at this point we should've already passed a bunch of tests
# relating to target submission above, so we can just test the
# classification specification feature here
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'N'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
firstClass = dao.addClassification(testIns)
self.assertNotEqual(firstClass, -1)
testIns.crop_id = 43
testIns.latitude = 40.222
testIns.longitude = -111.222
testIns.orientation = 'NE'
testIns.background_color = 'orange'
secondClass = dao.addClassification(testIns)
self.assertNotEqual(secondClass, -1)
testIns.crop_id = 44
testIns.latitude = 40.333
testIns.longitude = -111.333
testIns.alphanumeric_color = 'white'
thirdClass = dao.addClassification(testIns)
self.assertNotEqual(thirdClass, -1)
specs = {
'orientation': secondClass,
'crop_id': firstClass,
'alphanumeric_color': thirdClass
}
classResult = dao.getClassification(secondClass)
submissionResult = dao.submitPendingTarget(classResult.target, specs)
self.assertIsNotNone(submissionResult)
self.assertEqual(submissionResult.orientation, 'NE')
self.assertEqual(submissionResult.crop_id, 42)
self.assertEqual(submissionResult.alphanumeric_color, 'white')
self.assertEqual(submissionResult.background_color, 'orange')
self.assertEqual(submissionResult.alphanumeric, 'A')
truncateTable('outgoing_manual')
############################################
# test what happens when we put garbage in specs:
############################################
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'S'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'Q'
testIns.alphanumeric_color = 'black'
self.assertNotEqual(dao.addClassification(testIns), -1)
testIns.crop_id = 43
testIns.latitude = 40.222
testIns.longitude = -111.222
testIns.orientation = 'W'
testIns.background_color = 'orange'
secondClass = dao.addClassification(testIns)
self.assertNotEqual(secondClass, -1)
testIns.crop_id = 44
testIns.latitude = 40.333
testIns.longitude = -111.333
testIns.alphanumeric_color = 'white'
self.assertNotEqual(dao.addClassification(testIns), -1)
specs = {
'orientation': secondClass,
'crop_id': None,
'alphanumeric_color': 'wasdf'
}
classResult = dao.getClassification(secondClass)
submissionResult = dao.submitPendingTarget(classResult.target, specs)
# Even though we fed a bunch of garbage in specs, submission should
# still succeed, defaulting to most common value, for the garbage stuff
self.assertIsNotNone(submissionResult)
self.assertEqual(submissionResult.orientation, 'W')
self.assertEqual(submissionResult.alphanumeric_color, 'black')
self.assertEqual(submissionResult.background_color, 'orange')
self.assertEqual(submissionResult.alphanumeric, 'Q')
