def validate(self, doc):
if doc.get('created'):
doc['created'] = validateDate(doc.get('created'), 'created')
if doc.get('approach') in {'default', ''}:
del doc['approach']
if doc.get('score') is not None and doc.get('overallScore') is None:
scoring.computeAverageScores(doc['score'])
phase = self.model('phase', 'covalic').load(doc['phaseId'],
force=True)
doc['overallScore'] = scoring.computeOverallScore(doc, phase)
doc['latest'] = True
Model.update(self,
query={
'phaseId': doc['phaseId'],
'creatorId': doc['creatorId'],
'approach': doc.get('approach'),
'latest': True
},
update={'$set': {
'latest': False
}})
return doc
def validate(self, doc):
if doc.get('created'):
doc['created'] = validateDate(doc.get('created'), 'created')
if doc.get('approach') in {'default', ''}:
del doc['approach']
if doc.get('score') is not None and doc.get('overallScore') is None:
scoring.computeAverageScores(doc['score'])
phase = self.model('phase', 'covalic').load(
############################ /opt/covalic/girder/girder/utility/model_importer.py
############################ class ModelImporter(object): def model(model, plugin=None):
############################ model name is 'phase', plugin name is 'covalic'
doc['phaseId'],
force=True)
doc['overallScore'] = scoring.computeOverallScore(doc, phase)
doc['latest'] = True
Model.update(self,
query={
'phaseId': doc['phaseId'],
'creatorId': doc['creatorId'],
'approach': doc.get('approach'),
'latest': True
},
update={'$set': {
'latest': False
}})
return doc
def testInclusionProjDict(self, doc, inclusionProjDict):
Model._removeSupplementalFields(doc, inclusionProjDict)
assert doc == {
'_id': '1234',
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******'}
def testExclusionProjDict(self, doc, exclusionProjDict):
Model._removeSupplementalFields(doc, exclusionProjDict)
assert doc == {
'_id': '1234',
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'}
def validate(self, doc):
if doc.get('score') is not None and doc.get('overallScore') is None:
scoring.computeAverageScores(doc['score'])
phase = self.model('phase', 'challenge').load(
doc['phaseId'], force=True)
doc['overallScore'] = scoring.computeOverallScore(doc, phase)
doc['latest'] = True
Model.update(self, query={
'phaseId': doc['phaseId'],
'creatorId': doc['creatorId'],
'latest': True
}, update={
'$set': {'latest': False}
})
return doc
def testInclusionProjDictNewValue(self, inclusionProjDict):
retval = Model._supplementFields(inclusionProjDict, {'newValue'})
assert retval == {
'public': True,
'access': True,
'email': True,
'login': True,
'newValue': True
}
def testFlaseInclusionEdgeCase(self):
doc = {
'_id': 'id',
'login': '******',
'email': '*****@*****.**',
'firstName': 'fname',
'lastName': 'lname'
}
fields = {
'_id': False,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
Model._removeSupplementalFields(doc, fields)
assert doc == {
'login': '******',
'email': '*****@*****.**',
'firstName': 'fname',
'lastName': 'lname'}
def validate(self, doc):
if doc.get('created'):
doc['created'] = validateDate(doc.get('created'), 'created')
if doc.get('approach') in {'default', ''}:
del doc['approach']
if doc.get('score') is not None and doc.get('overallScore') is None:
scoring.computeAverageScores(doc['score'])
phase = Phase().load(
doc['phaseId'], force=True)
doc['overallScore'] = scoring.computeOverallScore(doc, phase)
doc['latest'] = True
Model.update(self, query={
'phaseId': doc['phaseId'],
'creatorId': doc['creatorId'],
'approach': doc.get('approach'),
'latest': True
}, update={
'$set': {'latest': False}
})
return doc
def testFalseInclusionEdgeCase(self):
fields = {
'_id': False,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
overwrittenFields = {
'_id': True,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
overwrite = {'_id', 'login'}
retval = Model._supplementFields(fields, overwrite)
assert retval == overwrittenFields
def testNoneEdgeCase(self):
# Test None edge cases
retval = Model._supplementFields(None, {'access', 'public'})
assert retval is None
def testExclusionProjDictOverride(self, exclusionProjDict, overrideFields):
retval = Model._supplementFields(exclusionProjDict, overrideFields)
assert retval == {'email': False, 'login': False}
def testExclusionProjDictNewValue(self, exclusionProjDict):
retval = Model._supplementFields(exclusionProjDict, {'newValue'})
assert retval == exclusionProjDict
def testInclusionProjListOverride(self, inclusionProjList, overrideFields):
retval = Model._supplementFields(inclusionProjList, overrideFields)
assert set(retval) == set(inclusionProjList)
def testProjectionUtils(self):
def assertItemsEqual(a, b):
self.assertEqual(len(a), len(b))
self.assertEqual(sorted(a), sorted(b))
inclusionProjDict = {
'public': True,
'access': True,
'email': True,
'login': True
}
inclusionProjList = ['public', 'access', 'email', 'login']
exclusionProjDict = {
'public': False,
'access': False,
'email': False,
'login': False
}
overrideFields = {'access', 'public'}
copy = dict(inclusionProjDict)
retval = Model._supplementFields(inclusionProjDict, overrideFields)
assertItemsEqual(retval, inclusionProjDict)
assertItemsEqual(inclusionProjDict, copy)
retval = Model._supplementFields(inclusionProjList, overrideFields)
assertItemsEqual(retval, inclusionProjList)
retval = Model._supplementFields(exclusionProjDict, {'newValue'})
assertItemsEqual(retval, exclusionProjDict)
retval = Model._supplementFields(inclusionProjDict, {'newValue'})
assertItemsEqual(
retval, {
'public': True,
'access': True,
'email': True,
'login': True,
'newValue': True
})
retval = Model._supplementFields(exclusionProjDict, overrideFields)
assertItemsEqual(retval, {'email': False, 'login': False})
originalDoc = {
'_id': '1234',
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******',
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'
}
doc = dict(originalDoc)
Model._removeSupplementalFields(doc, exclusionProjDict)
assertItemsEqual(
doc, {
'_id': '1234',
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'
})
doc = dict(originalDoc)
Model._removeSupplementalFields(doc, inclusionProjList)
assertItemsEqual(
doc, {
'_id': '1234',
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******'
})
doc = dict(originalDoc)
Model._removeSupplementalFields(doc, inclusionProjDict)
assertItemsEqual(
doc, {
'_id': '1234',
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******'
})
# Test None edge cases
retval = Model._supplementFields(None, {'access', 'public'})
self.assertIsNone(retval)
doc = dict(originalDoc)
Model._removeSupplementalFields(doc, None)
assertItemsEqual(doc, originalDoc)
# Test '_id': False inclusion edge case
fields = {
'_id': False,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
overwrittenFields = {
'_id': True,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
overwrite = {'_id', 'login'}
retval = Model._supplementFields(fields, overwrite)
assertItemsEqual(retval, overwrittenFields)
doc = {
'_id': 'id',
'login': '******',
'email': '*****@*****.**',
'firstName': 'fname',
'lastName': 'lname'
}
Model._removeSupplementalFields(doc, fields)
assertItemsEqual(
doc, {
'login': '******',
'email': '*****@*****.**',
'firstName': 'fname',
'lastName': 'lname'
})
# Test _isInclusionProjection edge cases
self.assertEqual(Model._isInclusionProjection(None), False)
self.assertEqual(Model._isInclusionProjection({}), True)
self.assertEqual(Model._isInclusionProjection({'_id': False}), False)
self.assertEqual(Model._isInclusionProjection({'_id': True}), True)
def remove(self, doc, progress=noProgress):
folder = self.model('folder').load(doc['folderId'], force=True)
if folder:
self.model('folder').remove(folder)
Model.remove(self, doc, progress=progress)
def remove(self, doc, progress=noProgress):
folder = self.model('folder').load(doc['folderId'], force=True)
if folder:
self.model('folder').remove(folder)
Model.remove(self, doc, progress=progress)
def testEmptyDict(self):
assert Model._isInclusionProjection({}) is True
def testNone(self):
assert Model._isInclusionProjection(None) is False
def testNoneEdgeCase(self, doc):
originalDoc = dict(doc)
Model._removeSupplementalFields(doc, None)
assert doc == originalDoc
def testIdTrue(self):
assert Model._isInclusionProjection({'_id': True}) is True
def remove(self, doc, progress=noProgress):
folder = Folder().load(doc['folderId'], force=True)
if folder:
Folder().remove(folder)
Model.remove(self, doc, progress=progress)
def testInclusionProjectDictOverride(self, inclusionProjDict, overrideFields):
copy = dict(inclusionProjDict)
retval = Model._supplementFields(inclusionProjDict, overrideFields)
assert retval == inclusionProjDict
assert inclusionProjDict == copy
def testIdFalse(self):
assert Model._isInclusionProjection({'_id': False}) is False
def testProjectionUtils(self):
def assertItemsEqual(a, b):
self.assertEqual(len(a), len(b))
self.assertEqual(sorted(a), sorted(b))
inclusionProjDict = {
'public': True,
'access': True,
'email': True,
'login': True
}
inclusionProjList = ['public', 'access', 'email', 'login']
exclusionProjDict = {
'public': False,
'access': False,
'email': False,
'login': False
}
overrideFields = {'access', 'public'}
copy = dict(inclusionProjDict)
retval = Model._overwriteFields(inclusionProjDict, overrideFields)
assertItemsEqual(retval, inclusionProjDict)
assertItemsEqual(inclusionProjDict, copy)
retval = Model._overwriteFields(inclusionProjList, overrideFields)
assertItemsEqual(retval, inclusionProjList)
retval = Model._overwriteFields(exclusionProjDict, {'newValue'})
assertItemsEqual(retval, exclusionProjDict)
retval = Model._overwriteFields(inclusionProjDict, {'newValue'})
assertItemsEqual(retval, {
'public': True,
'access': True,
'email': True,
'login': True,
'newValue': True
})
retval = Model._overwriteFields(exclusionProjDict, overrideFields)
assertItemsEqual(retval, {'email': False, 'login': False})
doc = {
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******',
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'
}
Model._removeOverwrittenFields(doc, exclusionProjDict)
assertItemsEqual(doc, {
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'})
doc = {
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******',
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'
}
Model._removeOverwrittenFields(doc, inclusionProjList)
assertItemsEqual(doc, {
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******'})
doc = {
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******',
'password': '******',
'admin': False,
'firstName': 'first',
'lastName': 'last'
}
Model._removeOverwrittenFields(doc, inclusionProjDict)
assertItemsEqual(doc, {
'public': True,
'access': True,
'email': '*****@*****.**',
'login': '******'})
# Test None edge cases
retval = Model._overwriteFields(None, {'access', 'public'})
self.assertIsNone(retval)
copy = dict(doc)
Model._removeOverwrittenFields(doc, None)
assertItemsEqual(copy, doc)
# Test '_id': False inclusion edge case
fields = {
'_id': False,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
overwrittenFields = {
'_id': True,
'login': True,
'email': True,
'firstName': True,
'lastName': True
}
overwrite = {'_id', 'login'}
retval = Model._overwriteFields(fields, overwrite)
assertItemsEqual(retval, overwrittenFields)
doc = {
'_id': 'id',
'login': '******',
'email': '*****@*****.**',
'firstName': 'fname',
'lastName': 'lname'
}
Model._removeOverwrittenFields(doc, fields)
assertItemsEqual(doc, {
'login': '******',
'email': '*****@*****.**',
'firstName': 'fname',
'lastName': 'lname'})
# Test _isInclusionProjection edge cases
self.assertEqual(Model._isInclusionProjection(None), False)
self.assertEqual(Model._isInclusionProjection({}), True)
self.assertEqual(Model._isInclusionProjection({'_id': False}), False)
self.assertEqual(Model._isInclusionProjection({'_id': True}), True)
