def test_default_stickers(self):
"""https://jira.bikalabs.com/browse/WINE-44: display SampleID or
SamplePartition ID depending on bikasetup.ShowPartitions value
"""
folder = self.portal.bika_setup.bika_analysisservices
services = [_createObjectByType("AnalysisService", folder, tmpID()),
_createObjectByType("AnalysisService", folder, tmpID())]
services[0].processForm()
services[1].processForm()
services[0].edit(title="Detect Dust")
services[1].edit(title="Detect water")
service_uids = [s.UID for s in services]
folder = self.portal.clients
client = _createObjectByType("Client", folder, tmpID())
client.processForm()
folder = self.portal.clients.objectValues("Client")[0]
contact = _createObjectByType("Contact", folder, tmpID())
contact.processForm()
contact.edit(Firstname="Bob", Surname="Dobbs", email="*****@*****.**")
folder = self.portal.bika_setup.bika_sampletypes
sampletype = _createObjectByType("SampleType", folder, tmpID())
sampletype.processForm()
sampletype.edit(title="Air", Prefix="AIR")
values = {'Client': client.UID(),
'Contact': contact.UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()}
for stemp in getStickerTemplates():
# create and receive AR
ar = create_analysisrequest(client, {}, values, service_uids)
ar.bika_setup.setShowPartitions(False)
doActionFor(ar, 'receive')
self.assertEquals(ar.portal_workflow.getInfoFor(ar, 'review_state'), 'sample_received')
# check sticker text
ar.REQUEST['items'] = ar.getId()
ar.REQUEST['template'] = stemp.get('id')
sticker = Sticker(ar, ar.REQUEST)()
pid = ar.getSample().objectValues("SamplePartition")[0].getId()
self.assertNotIn(pid, sticker, "Sticker must not contain partition ID %s"%pid)
# create and receive AR
ar = create_analysisrequest(client, {}, values, service_uids)
ar.bika_setup.setShowPartitions(True)
doActionFor(ar, 'receive')
self.assertEquals(ar.portal_workflow.getInfoFor(ar, 'review_state'), 'sample_received')
# check sticker text
ar.REQUEST['items'] = ar.getId()
ar.REQUEST['template'] = stemp.get('id')
sticker = Sticker(ar, ar.REQUEST)()
pid = ar.getSample().objectValues("SamplePartition")[0].getId()
self.assertIn(pid, sticker, "Sticker must contain partition ID %s"%pid)
def __call__(self):
form = self.request.form
CheckAuthenticator(self.request.form)
PostOnly(self.request.form)
uc = getToolByName(self.context, 'uid_catalog')
bsc = getToolByName(self.context, 'bika_setup_catalog')
portal_catalog = getToolByName(self.context, 'portal_catalog')
# Load the form data from request.state. If anything goes wrong here,
# put a bullet through the whole process.
try:
states = json.loads(form['state'])
except Exception as e:
message = t(_('Badly formed state: ${errmsg}',
mapping={'errmsg': e.message}))
ajax_form_error(self.errors, message=message)
return json.dumps({'errors': self.errors})
# Validate incoming form data
required = [field.getName() for field
in AnalysisRequestSchema.fields()
if field.required] + ["Analyses"]
# First remove all states which are completely empty; if all
# required fields are not present, we assume that the current
# AR had no data entered, and can be ignored
nonblank_states = {}
for arnum, state in states.items():
for key, val in state.items():
if val \
and "%s_hidden" % key not in state \
and not key.endswith('hidden'):
nonblank_states[arnum] = state
break
# in valid_states, all ars that pass validation will be stored
valid_states = {}
for arnum, state in nonblank_states.items():
# Secondary ARs are a special case, these fields are not required
if state.get('Sample', ''):
if 'SamplingDate' in required:
required.remove('SamplingDate')
if 'SampleType' in required:
required.remove('SampleType')
# fields flagged as 'hidden' are not considered required because
# they will already have default values inserted in them
for fieldname in required:
if fieldname + '_hidden' in state:
required.remove(fieldname)
missing = [f for f in required if not state.get(f, '')]
# If there are required fields missing, flag an error
if missing:
msg = t(_('Required fields have no values: '
'${field_names}',
mapping={'field_names': ', '.join(missing)}))
ajax_form_error(self.errors, arnum=arnum, message=msg)
continue
# This ar is valid!
valid_states[arnum] = state
# - Expand lists of UIDs returned by multiValued reference widgets
# - Transfer _uid values into their respective fields
for arnum in valid_states.keys():
for field, value in valid_states[arnum].items():
if field.endswith('_uid') and ',' in value:
valid_states[arnum][field] = value.split(',')
elif field.endswith('_uid'):
valid_states[arnum][field] = value
if self.errors:
return json.dumps({'errors': self.errors})
# Now, we will create the specified ARs.
ARs = []
for arnum, state in valid_states.items():
# Create the Analysis Request
ar = create_analysisrequest(
portal_catalog(UID=state['Client'])[0].getObject(),
self.request,
state
)
ARs.append(ar.Title())
# Display the appropriate message after creation
if len(ARs) > 1:
message = _('Analysis requests ${ARs} were successfully created.',
mapping={'ARs': safe_unicode(', '.join(ARs))})
else:
message = _('Analysis request ${AR} was successfully created.',
mapping={'AR': safe_unicode(ARs[0])})
self.context.plone_utils.addPortalMessage(message, 'info')
# Automatic label printing won't print "register" labels for Secondary. ARs
new_ars = [ar for ar in ARs if ar[-2:] == '01']
if 'register' in self.context.bika_setup.getAutoPrintStickers() \
and new_ars:
return json.dumps({
'success': message,
'stickers': new_ars,
'stickertemplate': self.context.bika_setup.getAutoStickerTemplate()
})
else:
return json.dumps({'success': message})
def __call__(self):
form = self.request.form
CheckAuthenticator(self.request.form)
PostOnly(self.request.form)
uc = getToolByName(self.context, 'uid_catalog')
bsc = getToolByName(self.context, 'bika_setup_catalog')
portal_catalog = getToolByName(self.context, 'portal_catalog')
# Load the form data from request.state. If anything goes wrong here,
# put a bullet through the whole process.
try:
states = json.loads(form['state'])
except Exception as e:
message = t(
_('Badly formed state: ${errmsg}',
mapping={'errmsg': e.message}))
ajax_form_error(self.errors, message=message)
return json.dumps({'errors': self.errors})
# Validate incoming form data
required = [
field.getName()
for field in AnalysisRequestSchema.fields() if field.required
] + ["Analyses"]
# First remove all states which are completely empty; if all
# required fields are not present, we assume that the current
# AR had no data entered, and can be ignored
nonblank_states = {}
for arnum, state in states.items():
for key, val in state.items():
if val \
and "%s_hidden" % key not in state \
and not key.endswith('hidden'):
nonblank_states[arnum] = state
break
# in valid_states, all ars that pass validation will be stored
valid_states = {}
for arnum, state in nonblank_states.items():
# Secondary ARs are a special case, these fields are not required
if state.get('Sample', ''):
if 'SamplingDate' in required:
required.remove('SamplingDate')
if 'SampleType' in required:
required.remove('SampleType')
# fields flagged as 'hidden' are not considered required because
# they will already have default values inserted in them
for fieldname in required:
if fieldname + '_hidden' in state:
required.remove(fieldname)
missing = [f for f in required if not state.get(f, '')]
# If there are required fields missing, flag an error
if missing:
msg = t(
_('Required fields have no values: '
'${field_names}',
mapping={'field_names': ', '.join(missing)}))
ajax_form_error(self.errors, arnum=arnum, message=msg)
continue
# This ar is valid!
valid_states[arnum] = state
# - Expand lists of UIDs returned by multiValued reference widgets
# - Transfer _uid values into their respective fields
for arnum in valid_states.keys():
for field, value in valid_states[arnum].items():
if field.endswith('_uid') and ',' in value:
valid_states[arnum][field] = value.split(',')
elif field.endswith('_uid'):
valid_states[arnum][field] = value
if self.errors:
return json.dumps({'errors': self.errors})
# Now, we will create the specified ARs.
ARs = []
for arnum, state in valid_states.items():
# Create the Analysis Request
ar = create_analysisrequest(
portal_catalog(UID=state['Client'])[0].getObject(),
self.request, state)
ARs.append(ar.Title())
# Display the appropriate message after creation
if len(ARs) > 1:
message = _('Analysis requests ${ARs} were successfully created.',
mapping={'ARs': safe_unicode(', '.join(ARs))})
else:
message = _('Analysis request ${AR} was successfully created.',
mapping={'AR': safe_unicode(ARs[0])})
self.context.plone_utils.addPortalMessage(message, 'info')
# Automatic label printing won't print "register" labels for Secondary. ARs
new_ars = [ar for ar in ARs if ar[-2:] == '01']
if 'register' in self.context.bika_setup.getAutoPrintStickers() \
and new_ars:
return json.dumps({
'success':
message,
'stickers':
new_ars,
'stickertemplate':
self.context.bika_setup.getAutoStickerTemplate()
})
else:
return json.dumps({'success': message})
def test_ar_manage_results_detectionlimit_selector_manual(self):
cases = [
# ROUND 1 ---------------------
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '5',
'expresult' : 5.0,
'expformattedresult': '< 10',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '15',
'expresult' : 15.0,
'expformattedresult': '15',
'isbelowldl' : False,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '25',
'expresult' : 25.0,
'expformattedresult': '> 20',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '<5',
'expresult' : 5.0, # '<' assignment not allowed
'expformattedresult': '< 10',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '<15',
'expresult' : 15.0, # '<' assignment not allowed
'expformattedresult': '15',
'isbelowldl' : False,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '>15',
'expresult' : 15.0, # '>' assignment not allowed
'expformattedresult': '15',
'isbelowldl' : False,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : False,
'manual' : False,
'input' : '25',
'expresult' : 25.0, # '>' assignment not allowed
'expformattedresult': '> 20',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : False},
# ROUND 2 ---------------------
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '5',
'expresult' : 5.0,
'expformattedresult': '< 10',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '15',
'expresult' : 15.0,
'expformattedresult': '15',
'isbelowldl' : False,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '25',
'expresult' : 25.0,
'expformattedresult': '> 20',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '<5',
'expresult' : 10.0, # '<' assignment allowed, but not custom
'expformattedresult': '< 10',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : True,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '<15',
'expresult' : 10.0, # '<' assignment allowed, but not custom
'expformattedresult': '< 10',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : True,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '>15',
'expresult' : 20.0, # '>' assignment allowed, but not custom
'expformattedresult': '> 20',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : True},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : False,
'input' : '>25',
'expresult' : 20.0, # '>' assignment allowed, but not custom
'expformattedresult': '> 20',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : True},
# ROUND 3 ---------------------
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '5',
'expresult' : 5.0,
'expformattedresult': '< 10',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '15',
'expresult' : 15.0,
'expformattedresult': '15',
'isbelowldl' : False,
'isaboveudl' : False,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '25',
'expresult' : 25.0,
'expformattedresult': '> 20',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '<5',
'expresult' : 5.0, # '<' assignment allowed
'expformattedresult': '< 5',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : True,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '<15',
'expresult' : 15.0, # '<' assignment allowed
'expformattedresult': '< 15',
'isbelowldl' : True,
'isaboveudl' : False,
'isldl' : True,
'isudl' : False},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '>15',
'expresult' : 15.0, # '>' assignment allowed
'expformattedresult': '> 15',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : True},
{'min' : '10',
'max' : '20',
'displaydl' : True,
'manual' : True,
'input' : '>25',
'expresult' : 25.0, # '>' assignment allowed
'expformattedresult': '> 25',
'isbelowldl' : False,
'isaboveudl' : True,
'isldl' : False,
'isudl' : True},
]
for case in cases:
s = self.services[0]
s.setDetectionLimitSelector(case['displaydl'])
s.setAllowManualDetectionLimit(case['manual'])
s.setLowerDetectionLimit(case['min'])
s.setUpperDetectionLimit(case['max'])
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
values = {'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()}
request = {}
ar = create_analysisrequest(client, request, values, [s.UID()])
wf = getToolByName(ar, 'portal_workflow')
wf.doActionFor(ar, 'receive')
an = ar.getAnalyses()[0].getObject()
an.setResult(case['input'])
self.assertEqual(an.isBelowLowerDetectionLimit(), case['isbelowldl'])
self.assertEqual(an.isAboveUpperDetectionLimit(), case['isaboveudl'])
self.assertEqual(an.isLowerDetectionLimit(), case['isldl'])
self.assertEqual(an.isUpperDetectionLimit(), case['isudl'])
self.assertEqual(float(an.getResult()), case['expresult'])
#import pdb; pdb.set_trace()
self.assertEqual(an.getFormattedResult(), case['expformattedresult'])
def test_ar_manageresults_limitdetections(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
values = {'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()}
request = {}
services = [s.UID() for s in self.services]
ar = create_analysisrequest(client, request, values, services)
# Basic detection limits
asidxs = {'analysisservice-3': 0,
'analysisservice-6': 1,
'analysisservice-7': 2}
for a in ar.getAnalyses():
an = a.getObject()
idx = asidxs[an.getService().id]
self.assertEqual(an.getLowerDetectionLimit(), float(self.lds[idx]['min']))
self.assertEqual(an.getUpperDetectionLimit(), float(self.lds[idx]['max']))
self.assertEqual(an.getService().getAllowManualDetectionLimit(), self.lds[idx]['manual'])
# Empty result
self.assertFalse(an.getDetectionLimitOperand())
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
# Set a result
an.setResult('15')
self.assertEqual(float(an.getResult()), 15)
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
an.setResult('-1')
self.assertEqual(float(an.getResult()), -1)
self.assertTrue(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '< %s' % (self.lds[idx]['min']))
an.setResult('2000')
self.assertEqual(float(an.getResult()), 2000)
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertTrue(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '> %s' % (self.lds[idx]['max']))
# Set a DL result
an.setResult('<15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertTrue(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '<')
self.assertEqual(an.getFormattedResult(), '< 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
an.setResult('>15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertTrue(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '>')
self.assertEqual(an.getFormattedResult(), '> 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
# Set a DL result explicitely
an.setDetectionLimitOperand('<')
an.setResult('15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertTrue(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '<')
self.assertEqual(an.getFormattedResult(), '< 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
an.setDetectionLimitOperand('>')
an.setResult('15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertTrue(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '>')
self.assertEqual(an.getFormattedResult(), '> 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
def test_service_hidden_analysisrequest(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper, Iron]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
request = {}
services = [s.UID() for s in self.services]
values = {
'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()
}
ar = create_analysisrequest(client, request, values, services)
self.assertFalse(
'hidden' in ar.getAnalysisServiceSettings(services[0]))
self.assertFalse(ar.isAnalysisServiceHidden(services[0]))
self.assertFalse(
ar.getAnalysisServiceSettings(services[1]).get('hidden'))
self.assertFalse(ar.isAnalysisServiceHidden(services[1]))
self.assertFalse(
ar.getAnalysisServiceSettings(services[2]).get('hidden'))
self.assertTrue(ar.isAnalysisServiceHidden(services[2]))
# For Calcium (unset)
uid = self.services[0].UID()
self.assertFalse(self.services[0].getHidden())
self.assertFalse(self.analysisprofile.isAnalysisServiceHidden(uid))
self.assertFalse(
'hidden' in self.artemplate.getAnalysisServiceSettings(uid))
# For Copper (False)
uid = self.services[1].UID()
self.assertFalse(self.services[1].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# For Iron (True)
uid = self.services[2].UID()
self.assertTrue(self.services[2].getHidden())
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# Modify visibility for Calcium in AR
uid = self.services[0].UID()
sets = [{'uid': uid}]
ar.setAnalysisServicesSettings(sets)
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
sets = [{'uid': uid, 'hidden': False}]
ar.setAnalysisServicesSettings(sets)
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertTrue('hidden' in ar.getAnalysisServiceSettings(uid))
sets = [{'uid': uid, 'hidden': True}]
ar.setAnalysisServicesSettings(sets)
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertTrue('hidden' in ar.getAnalysisServiceSettings(uid))
ar.setAnalysisServicesSettings([])
# AR with profile with no changes
values['Profile'] = self.analysisprofile.UID()
ar = create_analysisrequest(client, request, values, services)
self.assertFalse(
'hidden' in ar.getAnalysisServiceSettings(services[0]))
self.assertFalse(
ar.getAnalysisServiceSettings(services[1]).get('hidden'))
self.assertFalse(
ar.getAnalysisServiceSettings(services[2]).get('hidden'))
uid = self.services[0].UID()
self.assertFalse(self.services[0].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[1].UID()
self.assertFalse(self.services[1].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[2].UID()
self.assertTrue(self.services[2].getHidden())
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# AR with template with no changes
values['Template'] = self.artemplate
del values['Profile']
ar = create_analysisrequest(client, request, values, services)
self.assertFalse(
'hidden' in ar.getAnalysisServiceSettings(services[0]))
self.assertFalse(
ar.getAnalysisServiceSettings(services[1]).get('hidden'))
self.assertFalse(
ar.getAnalysisServiceSettings(services[2]).get('hidden'))
uid = self.services[0].UID()
self.assertFalse(self.services[0].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[1].UID()
self.assertFalse(self.services[1].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[2].UID()
self.assertTrue(self.services[2].getHidden())
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# AR with profile, with changes
values['Profile'] = self.analysisprofile.UID()
del values['Template']
matrix = [
[2, 1, -2], # AS = Not set
[2, 1, -2], # AS = False
[2, 1, -1]
]
for i in range(len(matrix)):
sets = {'uid': services[i]}
opts = [0, 1, 2]
for j in opts:
if j == 0:
sets['hidden'] = False
elif j == 1:
sets['hidden'] = True
else:
del sets['hidden']
self.analysisprofile.setAnalysisServicesSettings(sets)
ar = create_analysisrequest(client, request, values, services)
res = matrix[i][j]
if res < 0:
self.assertFalse(
'hidden' in ar.getAnalysisServiceSettings(services[i]))
else:
self.assertTrue(
'hidden' in ar.getAnalysisServiceSettings(services[i]))
if abs(res) == 1:
self.assertTrue(ar.isAnalysisServiceHidden(services[i]))
elif abs(res) == 2:
self.assertFalse(ar.isAnalysisServiceHidden(services[i]))
# Restore
self.analysisprofile.setAnalysisServicesSettings([])
# AR with template, with changes
values['Template'] = self.artemplate.UID()
del values['Profile']
matrix = [
[2, 1, -2], # AS = Not set
[2, 1, -2], # AS = False
[2, 1, -1]
]
for i in range(len(matrix)):
sets = {'uid': services[i]}
opts = [0, 1, 2]
for j in opts:
if j == 0:
sets['hidden'] = False
elif j == 1:
sets['hidden'] = True
else:
del sets['hidden']
self.artemplate.setAnalysisServicesSettings(sets)
ar = create_analysisrequest(client, request, values, services)
res = matrix[i][j]
if res < 0:
self.assertFalse(
'hidden' in ar.getAnalysisServiceSettings(services[i]))
else:
self.assertTrue(
'hidden' in ar.getAnalysisServiceSettings(services[i]))
if abs(res) == 1:
self.assertTrue(ar.isAnalysisServiceHidden(services[i]))
elif abs(res) == 2:
self.assertFalse(ar.isAnalysisServiceHidden(services[i]))
# Restore
self.artemplate.setAnalysisServicesSettings([])
def test_analysis_method_calculation(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Mg, Total Hardness]
for f in self.formulas:
# Set custom calculation
self.calculation.setFormula(f['formula'])
self.assertEqual(self.calculation.getFormula(), f['formula'])
interims = []
for k, v in f['interims'].items():
interims.append({
'keyword': k,
'title': k,
'value': v,
'hidden': False,
'type': 'int',
'unit': ''
})
self.calculation.setInterimFields(interims)
self.assertEqual(self.calculation.getInterimFields(), interims)
# Create the AR
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes[
'sampletype-1']
values = {
'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()
}
request = {}
services = [s.UID()
for s in self.services] + [self.calcservice.UID()]
ar = create_analysisrequest(client, request, values, services)
wf = getToolByName(ar, 'portal_workflow')
wf.doActionFor(ar, 'receive')
# Set results and interims
calcanalysis = None
for an in ar.getAnalyses():
an = an.getObject()
key = an.getKeyword()
if key in f['analyses']:
an.setResult(f['analyses'][key])
if an.isLowerDetectionLimit() \
or an.isUpperDetectionLimit():
operator = an.getDetectionLimitOperand()
strres = f['analyses'][key].replace(operator, '')
self.assertEqual(an.getResult(), str(float(strres)))
else:
self.assertEqual(an.getResult(), f['analyses'][key])
elif key == self.calcservice.getKeyword():
calcanalysis = an
# Set interims
interims = an.getInterimFields()
intermap = []
for i in interims:
if i['keyword'] in f['interims']:
ival = float(f['interims'][i['keyword']])
intermap.append({
'keyword': i['keyword'],
'value': ival,
'title': i['title'],
'hidden': i['hidden'],
'type': i['type'],
'unit': i['unit']
})
else:
intermap.append(i)
an.setInterimFields(intermap)
self.assertEqual(an.getInterimFields(), intermap)
# Let's go.. calculate and check result
calcanalysis.calculateResult(True, True)
self.assertEqual(float(calcanalysis.getResult()),
float(f['exresult']))
def test_service_hidden_analysisrequest(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper, Iron]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
request = {}
services = [s.UID() for s in self.services]
values = {'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()}
ar = create_analysisrequest(client, request, values, services)
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(services[0]))
self.assertFalse(ar.isAnalysisServiceHidden(services[0]))
self.assertFalse(ar.getAnalysisServiceSettings(services[1]).get('hidden'))
self.assertFalse(ar.isAnalysisServiceHidden(services[1]))
self.assertFalse(ar.getAnalysisServiceSettings(services[2]).get('hidden'))
self.assertTrue(ar.isAnalysisServiceHidden(services[2]))
# For Calcium (unset)
uid = self.services[0].UID()
self.assertFalse(self.services[0].getHidden())
self.assertFalse(self.analysisprofile.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in self.artemplate.getAnalysisServiceSettings(uid))
# For Copper (False)
uid = self.services[1].UID()
self.assertFalse(self.services[1].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# For Iron (True)
uid = self.services[2].UID()
self.assertTrue(self.services[2].getHidden())
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# Modify visibility for Calcium in AR
uid = self.services[0].UID();
sets = [{'uid': uid}]
ar.setAnalysisServicesSettings(sets)
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
sets = [{'uid': uid, 'hidden': False}]
ar.setAnalysisServicesSettings(sets)
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertTrue('hidden' in ar.getAnalysisServiceSettings(uid))
sets = [{'uid': uid, 'hidden': True}]
ar.setAnalysisServicesSettings(sets)
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertTrue('hidden' in ar.getAnalysisServiceSettings(uid))
ar.setAnalysisServicesSettings([])
# AR with profile with no changes
values['Profile'] = self.analysisprofile.UID()
ar = create_analysisrequest(client, request, values, services)
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(services[0]))
self.assertFalse(ar.getAnalysisServiceSettings(services[1]).get('hidden'))
self.assertFalse(ar.getAnalysisServiceSettings(services[2]).get('hidden'))
uid = self.services[0].UID()
self.assertFalse(self.services[0].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[1].UID()
self.assertFalse(self.services[1].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[2].UID()
self.assertTrue(self.services[2].getHidden())
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# AR with template with no changes
values['Template'] = self.artemplate
del values['Profile']
ar = create_analysisrequest(client, request, values, services)
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(services[0]))
self.assertFalse(ar.getAnalysisServiceSettings(services[1]).get('hidden'))
self.assertFalse(ar.getAnalysisServiceSettings(services[2]).get('hidden'))
uid = self.services[0].UID()
self.assertFalse(self.services[0].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[1].UID()
self.assertFalse(self.services[1].getHidden())
self.assertFalse(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
uid = self.services[2].UID()
self.assertTrue(self.services[2].getHidden())
self.assertTrue(ar.isAnalysisServiceHidden(uid))
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(uid))
# AR with profile, with changes
values['Profile'] = self.analysisprofile.UID()
del values['Template']
matrix = [[2, 1,-2], # AS = Not set
[2, 1,-2], # AS = False
[2, 1,-1]]
for i in range(len(matrix)):
sets = {'uid': services[i]}
opts = [0, 1, 2]
for j in opts:
if j == 0:
sets['hidden'] = False
elif j == 1:
sets['hidden'] = True
else:
del sets['hidden']
self.analysisprofile.setAnalysisServicesSettings(sets)
ar = create_analysisrequest(client, request, values, services)
res = matrix[i][j]
if res < 0:
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(services[i]))
else:
self.assertTrue('hidden' in ar.getAnalysisServiceSettings(services[i]))
if abs(res) == 1:
self.assertTrue(ar.isAnalysisServiceHidden(services[i]))
elif abs(res) == 2:
self.assertFalse(ar.isAnalysisServiceHidden(services[i]))
# Restore
self.analysisprofile.setAnalysisServicesSettings([])
# AR with template, with changes
values['Template'] = self.artemplate.UID()
del values['Profile']
matrix = [[2, 1,-2], # AS = Not set
[2, 1,-2], # AS = False
[2, 1,-1]]
for i in range(len(matrix)):
sets = {'uid': services[i]}
opts = [0, 1, 2]
for j in opts:
if j == 0:
sets['hidden'] = False
elif j == 1:
sets['hidden'] = True
else:
del sets['hidden']
self.artemplate.setAnalysisServicesSettings(sets)
ar = create_analysisrequest(client, request, values, services)
res = matrix[i][j]
if res < 0:
self.assertFalse('hidden' in ar.getAnalysisServiceSettings(services[i]))
else:
self.assertTrue('hidden' in ar.getAnalysisServiceSettings(services[i]))
if abs(res) == 1:
self.assertTrue(ar.isAnalysisServiceHidden(services[i]))
elif abs(res) == 2:
self.assertFalse(ar.isAnalysisServiceHidden(services[i]))
# Restore
self.artemplate.setAnalysisServicesSettings([])
def test_ar_manage_results_detectionlimit_selector_manual(self):
cases = [
# ROUND 1 ---------------------
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '5',
'expresult': 5.0,
'expformattedresult': '< 10',
'isbelowldl': True,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '15',
'expresult': 15.0,
'expformattedresult': '15',
'isbelowldl': False,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '25',
'expresult': 25.0,
'expformattedresult': '> 20',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '<5',
'expresult': 5.0, # '<' assignment not allowed
'expformattedresult': '< 10',
'isbelowldl': True,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '<15',
'expresult': 15.0, # '<' assignment not allowed
'expformattedresult': '15',
'isbelowldl': False,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '>15',
'expresult': 15.0, # '>' assignment not allowed
'expformattedresult': '15',
'isbelowldl': False,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': False,
'manual': False,
'input': '25',
'expresult': 25.0, # '>' assignment not allowed
'expformattedresult': '> 20',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': False
},
# ROUND 2 ---------------------
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '5',
'expresult': 5.0,
'expformattedresult': '< 10',
'isbelowldl': True,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '15',
'expresult': 15.0,
'expformattedresult': '15',
'isbelowldl': False,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '25',
'expresult': 25.0,
'expformattedresult': '> 20',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '<5',
'expresult': 10.0, # '<' assignment allowed, but not custom
'expformattedresult': '< 10',
'isbelowldl': True,
'isaboveudl': False,
'isldl': True,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '<15',
'expresult': 10.0, # '<' assignment allowed, but not custom
'expformattedresult': '< 10',
'isbelowldl': True,
'isaboveudl': False,
'isldl': True,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '>15',
'expresult': 20.0, # '>' assignment allowed, but not custom
'expformattedresult': '> 20',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': True
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': False,
'input': '>25',
'expresult': 20.0, # '>' assignment allowed, but not custom
'expformattedresult': '> 20',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': True
},
# ROUND 3 ---------------------
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '5',
'expresult': 5.0,
'expformattedresult': '< 10',
'isbelowldl': True,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '15',
'expresult': 15.0,
'expformattedresult': '15',
'isbelowldl': False,
'isaboveudl': False,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '25',
'expresult': 25.0,
'expformattedresult': '> 20',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '<5',
'expresult': 5.0, # '<' assignment allowed
'expformattedresult': '< 5',
'isbelowldl': True,
'isaboveudl': False,
'isldl': True,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '<15',
'expresult': 15.0, # '<' assignment allowed
'expformattedresult': '< 15',
'isbelowldl': True,
'isaboveudl': False,
'isldl': True,
'isudl': False
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '>15',
'expresult': 15.0, # '>' assignment allowed
'expformattedresult': '> 15',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': True
},
{
'min': '10',
'max': '20',
'displaydl': True,
'manual': True,
'input': '>25',
'expresult': 25.0, # '>' assignment allowed
'expformattedresult': '> 25',
'isbelowldl': False,
'isaboveudl': True,
'isldl': False,
'isudl': True
},
]
for case in cases:
s = self.services[0]
s.setDetectionLimitSelector(case['displaydl'])
s.setAllowManualDetectionLimit(case['manual'])
s.setLowerDetectionLimit(case['min'])
s.setUpperDetectionLimit(case['max'])
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes[
'sampletype-1']
values = {
'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()
}
request = {}
ar = create_analysisrequest(client, request, values, [s.UID()])
wf = getToolByName(ar, 'portal_workflow')
wf.doActionFor(ar, 'receive')
an = ar.getAnalyses()[0].getObject()
an.setResult(case['input'])
self.assertEqual(an.isBelowLowerDetectionLimit(),
case['isbelowldl'])
self.assertEqual(an.isAboveUpperDetectionLimit(),
case['isaboveudl'])
self.assertEqual(an.isLowerDetectionLimit(), case['isldl'])
self.assertEqual(an.isUpperDetectionLimit(), case['isudl'])
self.assertEqual(float(an.getResult()), case['expresult'])
#import pdb; pdb.set_trace()
self.assertEqual(an.getFormattedResult(),
case['expformattedresult'])
def test_ar_manageresults_limitdetections(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
values = {
'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()
}
request = {}
services = [s.UID() for s in self.services]
ar = create_analysisrequest(client, request, values, services)
# Basic detection limits
asidxs = {
'analysisservice-3': 0,
'analysisservice-6': 1,
'analysisservice-7': 2
}
for a in ar.getAnalyses():
an = a.getObject()
idx = asidxs[an.getService().id]
self.assertEqual(an.getLowerDetectionLimit(),
float(self.lds[idx]['min']))
self.assertEqual(an.getUpperDetectionLimit(),
float(self.lds[idx]['max']))
self.assertEqual(an.getService().getAllowManualDetectionLimit(),
self.lds[idx]['manual'])
# Empty result
self.assertFalse(an.getDetectionLimitOperand())
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
# Set a result
an.setResult('15')
self.assertEqual(float(an.getResult()), 15)
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
an.setResult('-1')
self.assertEqual(float(an.getResult()), -1)
self.assertTrue(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(),
'< %s' % (self.lds[idx]['min']))
an.setResult('2000')
self.assertEqual(float(an.getResult()), 2000)
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertTrue(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(),
'> %s' % (self.lds[idx]['max']))
# Set a DL result
an.setResult('<15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertTrue(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '<')
self.assertEqual(an.getFormattedResult(), '< 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
an.setResult('>15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertTrue(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '>')
self.assertEqual(an.getFormattedResult(), '> 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
# Set a DL result explicitely
an.setDetectionLimitOperand('<')
an.setResult('15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertTrue(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '<')
self.assertEqual(an.getFormattedResult(), '< 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
an.setDetectionLimitOperand('>')
an.setResult('15')
self.assertEqual(float(an.getResult()), 15)
if self.lds[idx]['manual']:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertTrue(an.isAboveUpperDetectionLimit())
self.assertEqual(an.getDetectionLimitOperand(), '>')
self.assertEqual(an.getFormattedResult(), '> 15')
else:
self.assertFalse(an.isBelowLowerDetectionLimit())
self.assertFalse(an.isAboveUpperDetectionLimit())
self.assertFalse(an.getDetectionLimitOperand())
self.assertEqual(an.getFormattedResult(), '15')
def test_analysis_method_calculation(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Mg, Total Hardness]
for f in self.formulas:
# Set custom calculation
self.calculation.setFormula(f['formula'])
self.assertEqual(self.calculation.getFormula(), f['formula'])
interims = []
for k,v in f['interims'].items():
interims.append({'keyword': k, 'title':k, 'value': v,
'hidden': False, 'type': 'int',
'unit': ''});
self.calculation.setInterimFields(interims)
self.assertEqual(self.calculation.getInterimFields(), interims)
# Create the AR
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
values = {'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()}
request = {}
services = [s.UID() for s in self.services] + [self.calcservice.UID()]
ar = create_analysisrequest(client, request, values, services)
wf = getToolByName(ar, 'portal_workflow')
wf.doActionFor(ar, 'receive')
# Set results and interims
calcanalysis = None
for an in ar.getAnalyses():
an = an.getObject()
key = an.getKeyword()
if key in f['analyses']:
an.setResult(f['analyses'][key])
if an.isLowerDetectionLimit() \
or an.isUpperDetectionLimit():
operator = an.getDetectionLimitOperand()
strres = f['analyses'][key].replace(operator, '')
self.assertEqual(an.getResult(), str(float(strres)))
else:
self.assertEqual(an.getResult(), f['analyses'][key])
elif key == self.calcservice.getKeyword():
calcanalysis = an
# Set interims
interims = an.getInterimFields()
intermap = []
for i in interims:
if i['keyword'] in f['interims']:
ival = float(f['interims'][i['keyword']])
intermap.append({'keyword': i['keyword'],
'value': ival,
'title': i['title'],
'hidden': i['hidden'],
'type': i['type'],
'unit': i['unit']})
else:
intermap.append(i)
an.setInterimFields(intermap)
self.assertEqual(an.getInterimFields(), intermap)
# Let's go.. calculate and check result
calcanalysis.calculateResult(True, True)
self.assertEqual(float(calcanalysis.getResult()), float(f['exresult']))
def test_ar_manageresults_manualuncertainty(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
values = {'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()}
request = {}
services = [s.UID() for s in self.services]
ar = create_analysisrequest(client, request, values, services)
# Basic uncertainty input
for a in ar.getAnalyses():
an = a.getObject()
self.assertFalse(an.getUncertainty())
an.setUncertainty('0.2')
self.assertEqual(an.getUncertainty(), 0.2)
an.setUncertainty('0.4')
self.assertEqual(an.getUncertainty(), 0.4)
an.setUncertainty(None)
self.assertFalse(an.getUncertainty())
# Copper (advanced uncertainty)
cu = [a.getObject() for a in ar.getAnalyses() \
if a.getObject().getServiceUID() == self.services[1].UID()][0]
self.assertFalse(cu.getUncertainty())
# Uncertainty range 5 - 10 (0.2)
cu.setResult('5.5')
self.assertEqual(cu.getResult(), '5.5')
self.assertEqual(cu.getUncertainty(), 0.02)
cu.setUncertainty('0.8')
self.assertEqual(cu.getUncertainty(), 0.8)
cu.setUncertainty(None)
self.assertEqual(cu.getUncertainty(), 0.02)
# Uncertainty range 10 - 20 (0.4)
cu.setResult('15.5')
self.assertEqual(cu.getResult(), '15.5')
self.assertEqual(cu.getUncertainty(), 0.4)
cu.setUncertainty('0.7')
self.assertEqual(cu.getUncertainty(), 0.7)
cu.setUncertainty(None)
self.assertEqual(cu.getUncertainty(), 0.4)
# Uncertainty range >20 (None)
cu.setResult('25.5')
self.assertEqual(cu.getResult(), '25.5')
self.assertFalse(cu.getUncertainty())
cu.setUncertainty('0.9')
self.assertEqual(cu.getUncertainty(), 0.9)
cu.setUncertainty(None)
self.assertFalse(cu.getUncertainty())
# Iron (advanced uncertainty with precision)
fe = [a.getObject() for a in ar.getAnalyses() \
if a.getObject().getServiceUID() == self.services[2].UID()][0]
self.assertFalse(cu.getUncertainty())
# Uncertainty range 0 - 5 (0.0015)
fe.setResult('2.3452')
self.assertEqual(fe.getUncertainty(), 0.0015)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.345')
fe.setUncertainty('0.06')
self.assertEqual(fe.getUncertainty(), 0.06)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.35')
fe.setUncertainty('0.7')
self.assertEqual(fe.getUncertainty(), 0.7)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.3')
fe.setUncertainty(None)
self.assertEqual(fe.getUncertainty(), 0.0015)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.345')
# Uncertainty range 5 - 10 (0.02)
fe.setResult('8.23462')
self.assertEqual(fe.getUncertainty(), 0.02)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.23')
fe.setUncertainty('0.6')
self.assertEqual(fe.getUncertainty(), 0.6)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.2')
fe.setUncertainty('0.07')
self.assertEqual(fe.getUncertainty(), 0.07)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.23')
fe.setUncertainty(None)
self.assertEqual(fe.getUncertainty(), 0.02)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.23')
# Uncertainty range >20 (None)
fe.setResult('25.523345')
self.assertFalse(fe.getUncertainty())
self.assertEqual(fe.getResult(), '25.523345')
self.assertEqual(fe.getPrecision(), 2)
self.assertEqual(fe.getService().getPrecision(), 2)
self.assertEqual(fe.getFormattedResult(), '25.52')
fe.setUncertainty('0.9')
self.assertEqual(fe.getUncertainty(), 0.9)
self.assertEqual(fe.getResult(), '25.523345')
self.assertEqual(fe.getPrecision(), 1)
self.assertEqual(fe.getService().getPrecision(), 2)
self.assertEqual(fe.getFormattedResult(), '25.5')
fe.setUncertainty(None)
self.assertFalse(fe.getUncertainty())
self.assertEqual(fe.getResult(), '25.523345')
self.assertEqual(fe.getPrecision(), 2)
self.assertEqual(fe.getService().getPrecision(), 2)
self.assertEqual(fe.getFormattedResult(), '25.52')
def test_ar_manageresults_manualuncertainty(self):
# Input results
# Client: Happy Hills
# SampleType: Apple Pulp
# Contact: Rita Mohale
# Analyses: [Calcium, Copper]
client = self.portal.clients['client-1']
sampletype = self.portal.bika_setup.bika_sampletypes['sampletype-1']
values = {
'Client': client.UID(),
'Contact': client.getContacts()[0].UID(),
'SamplingDate': '2015-01-01',
'SampleType': sampletype.UID()
}
request = {}
services = [s.UID() for s in self.services]
ar = create_analysisrequest(client, request, values, services)
# Basic uncertainty input
for a in ar.getAnalyses():
an = a.getObject()
self.assertFalse(an.getUncertainty())
an.setUncertainty('0.2')
self.assertEqual(an.getUncertainty(), 0.2)
an.setUncertainty('0.4')
self.assertEqual(an.getUncertainty(), 0.4)
an.setUncertainty(None)
self.assertFalse(an.getUncertainty())
# Copper (advanced uncertainty)
cu = [a.getObject() for a in ar.getAnalyses() \
if a.getObject().getServiceUID() == self.services[1].UID()][0]
self.assertFalse(cu.getUncertainty())
# Uncertainty range 5 - 10 (0.2)
cu.setResult('5.5')
self.assertEqual(cu.getResult(), '5.5')
self.assertEqual(cu.getUncertainty(), 0.02)
cu.setUncertainty('0.8')
self.assertEqual(cu.getUncertainty(), 0.8)
cu.setUncertainty(None)
self.assertEqual(cu.getUncertainty(), 0.02)
# Uncertainty range 10 - 20 (0.4)
cu.setResult('15.5')
self.assertEqual(cu.getResult(), '15.5')
self.assertEqual(cu.getUncertainty(), 0.4)
cu.setUncertainty('0.7')
self.assertEqual(cu.getUncertainty(), 0.7)
cu.setUncertainty(None)
self.assertEqual(cu.getUncertainty(), 0.4)
# Uncertainty range >20 (None)
cu.setResult('25.5')
self.assertEqual(cu.getResult(), '25.5')
self.assertFalse(cu.getUncertainty())
cu.setUncertainty('0.9')
self.assertEqual(cu.getUncertainty(), 0.9)
cu.setUncertainty(None)
self.assertFalse(cu.getUncertainty())
# Iron (advanced uncertainty with precision)
fe = [a.getObject() for a in ar.getAnalyses() \
if a.getObject().getServiceUID() == self.services[2].UID()][0]
self.assertFalse(cu.getUncertainty())
# Uncertainty range 0 - 5 (0.0015)
fe.setResult('2.3452')
self.assertEqual(fe.getUncertainty(), 0.0015)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.345')
fe.setUncertainty('0.06')
self.assertEqual(fe.getUncertainty(), 0.06)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.35')
fe.setUncertainty('0.7')
self.assertEqual(fe.getUncertainty(), 0.7)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.3')
fe.setUncertainty(None)
self.assertEqual(fe.getUncertainty(), 0.0015)
self.assertEqual(fe.getResult(), '2.3452')
self.assertEqual(fe.getFormattedResult(), '2.345')
# Uncertainty range 5 - 10 (0.02)
fe.setResult('8.23462')
self.assertEqual(fe.getUncertainty(), 0.02)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.23')
fe.setUncertainty('0.6')
self.assertEqual(fe.getUncertainty(), 0.6)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.2')
fe.setUncertainty('0.07')
self.assertEqual(fe.getUncertainty(), 0.07)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.23')
fe.setUncertainty(None)
self.assertEqual(fe.getUncertainty(), 0.02)
self.assertEqual(fe.getResult(), '8.23462')
self.assertEqual(fe.getFormattedResult(), '8.23')
# Uncertainty range >20 (None)
fe.setResult('25.523345')
self.assertFalse(fe.getUncertainty())
self.assertEqual(fe.getResult(), '25.523345')
self.assertEqual(fe.getPrecision(), 2)
self.assertEqual(fe.getService().getPrecision(), 2)
self.assertEqual(fe.getFormattedResult(), '25.52')
fe.setUncertainty('0.9')
self.assertEqual(fe.getUncertainty(), 0.9)
self.assertEqual(fe.getResult(), '25.523345')
self.assertEqual(fe.getPrecision(), 1)
self.assertEqual(fe.getService().getPrecision(), 2)
self.assertEqual(fe.getFormattedResult(), '25.5')
fe.setUncertainty(None)
self.assertFalse(fe.getUncertainty())
self.assertEqual(fe.getResult(), '25.523345')
self.assertEqual(fe.getPrecision(), 2)
self.assertEqual(fe.getService().getPrecision(), 2)
self.assertEqual(fe.getFormattedResult(), '25.52')
