def prepare_new_task(self):
new_task_props = [
TaskEnvironmentProperties(
environmentName=self.existing_environment_name,
deps=self.existing_direct_flag,
personas=self.existing_personas,
assets=self.existing_assets,
concs=self.existing_concern_associations,
narrative=self.existing_narrative,
consequences=self.existing_consequences,
benefits=self.existing_benefits,
tCodes=self.existing_codes)
]
new_task = Task(tId=-1,
tName='New task',
tShortCode='NT',
tObjt='New objective',
isAssumption=True,
tAuth='New Author',
tags=[],
cProps=[])
new_task.theEnvironmentProperties = new_task_props
new_task.theEnvironmentDictionary = {}
delattr(new_task, 'theEnvironmentDictionary')
return new_task
def OnEnvironmentDeselected(self,evt):
self.theSelectedIdx = evt.GetIndex()
environmentName = self.environmentList.GetItemText(self.theSelectedIdx)
envCodebook = {'narrative':self.narrativeCtrl.codes(),'consequences':self.consequencesCtrl.codes(),'benefits':self.benefitsCtrl.codes()}
self.theEnvironmentDictionary[environmentName] = TaskEnvironmentProperties(environmentName,self.dependenciesCtrl.GetValue(),self.personaList.dimensions(),self.assetList.dimensions(),self.caList.dimensions(),self.narrativeCtrl.GetValue(),self.consequencesCtrl.GetValue(),self.benefitsCtrl.GetValue(),envCodebook)
self.dependenciesCtrl.SetValue('')
self.personaList.setEnvironment('')
self.assetList.setEnvironment('')
self.caList.setEnvironment('')
self.narrativeCtrl.setEnvironment('')
self.personaList.DeleteAllItems()
self.assetList.DeleteAllItems()
self.caList.DeleteAllItems()
self.narrativeCtrl.SetValue('')
self.consequencesCtrl.SetValue('')
self.benefitsCtrl.SetValue('')
self.narrativeCtrl.setCodes({})
self.consequencesCtrl.setCodes({})
self.benefitsCtrl.setCodes({})
self.theSelectedIdx = -1
self.dependenciesCtrl.Disable()
self.personaList.Disable()
self.assetList.Disable()
self.caList.Disable()
self.narrativeCtrl.Disable()
self.consequencesCtrl.Disable()
self.benefitsCtrl.Disable()
def endElement(self,name):
if name == 'persona':
p = PersonaParameters(self.theName,unescape(self.theActivities),unescape(self.theAttitudes),unescape(self.theAptitudes),unescape(self.theMotivations),unescape(self.theSkills),unescape(self.theIntrinsic),unescape(self.theContextual),self.theImage,self.isAssumptionPersona,self.theType,self.theTags,self.theEnvironmentProperties,{})
self.thePersonas.append(p)
self.resetPersonaAttributes()
elif name == 'persona_environment':
p = PersonaEnvironmentProperties(self.theEnvironmentName,self.isDirect,unescape(self.theNarrative),self.theRoles,{'narrative':{}})
self.theEnvironmentProperties.append(p)
self.resetPersonaEnvironmentAttributes()
elif name == 'external_document':
p = ExternalDocumentParameters(self.theName,self.theVersion,self.theDate,self.theAuthors,unescape(self.theDescription))
self.theExternalDocuments.append(p)
self.resetExternalDocumentAttributes()
elif name == 'document_reference':
p = DocumentReferenceParameters(self.theName,self.theDocument,self.theContributor,unescape(self.theExcerpt))
self.theDocumentReferences.append(p)
self.resetDocumentReferenceAttributes()
elif name == 'persona_characteristic':
p = PersonaCharacteristicParameters(self.thePersona,self.theModalQualifier,self.theBvName,unescape(self.theDefinition),self.theGrounds,self.theWarrants,[],self.theRebuttals)
self.thePersonaCharacteristics.append(p)
self.resetPersonaCharacteristicAttributes()
elif name == 'task':
p = TaskParameters(unescape(self.theName),unescape(self.theCode),unescape(self.theObjective),self.isAssumptionTask,self.theAuthor,self.theTags,self.theEnvironmentProperties)
self.theTasks.append(p)
self.resetTaskAttributes()
elif name == 'task_environment':
p = TaskEnvironmentProperties(unescape(self.theEnvironmentName),unescape(self.theDependencies),self.theTaskPersonas,self.theConcerns,self.theConcernAssociations,unescape(self.theNarrative),unescape(self.theConsequences),unescape(self.theBenefits),[],{'narrative':{},'consequences':{},'benefits':{}})
self.theEnvironmentProperties.append(p)
self.resetTaskEnvironmentAttributes()
elif name == 'activities':
self.inActivities = 0
elif name == 'attitudes':
self.inAttitudes = 0
elif name == 'aptitudes':
self.inAptitudes = 0
elif name == 'motivations':
self.inMotivations = 0
elif name == 'skills':
self.inSkills = 0
elif name == 'intrinsic':
self.inIntrinsic = 0
elif name == 'contextual':
self.inContextual = 0
elif name == 'narrative':
self.inNarrative = 0
elif name == 'excerpt':
self.inExcerpt = 0
elif name == 'description':
self.inDescription = 0
elif name == 'definition':
self.inDefinition = 0
elif name == 'dependencies':
self.inDependencies = 0
elif name == 'objective':
self.inObjective = 0
elif name == 'benefits':
self.inBenefits = 0
elif name == 'consequences':
self.inConsequences = 0
def convert_props(self, real_props=None, fake_props=None):
new_props = []
if real_props is not None:
if len(real_props) > 0:
for real_prop in real_props:
assert isinstance(real_prop, TaskEnvironmentProperties)
del real_prop.theCodes
ptList = []
for ptc in real_prop.personas():
ptList.append(
PersonaTaskCharacteristics(ptc[0], ptc[1], ptc[2],
ptc[3], ptc[4]))
real_prop.thePersonas = ptList
gcaList = []
for gca in real_prop.concernAssociations():
gcaList.append(
ConcernAssociationModel(gca[0], gca[1], gca[2],
gca[3], gca[4]))
real_prop.theConcernAssociations = gcaList
new_props.append(real_prop)
elif fake_props is not None:
if len(fake_props) > 0:
for fake_prop in fake_props:
check_required_keys(
fake_prop, TaskEnvironmentPropertiesModel.required)
ptList = []
for ptc in fake_prop['thePersonas']:
ptList.append([
ptc['thePersona'], ptc['theDuration'],
ptc['theFrequency'], ptc['theDemands'],
ptc['theGoalConflict']
])
fake_prop['thePersonas'] = ptList
gcaList = []
for gca in fake_prop['theConcernAssociations']:
gcaList.append([
gca['theSource'], gca['theSourceNry'],
gca['theLinkVerb'], gca['theTarget'],
gca['theTargetNry']
])
fake_prop['theConcernAssociations'] = gcaList
new_prop = TaskEnvironmentProperties(
environmentName=fake_prop['theEnvironmentName'],
deps=fake_prop['theDependencies'],
personas=fake_prop['thePersonas'],
assets=fake_prop['theAssets'],
concs=fake_prop['theConcernAssociations'],
narrative=fake_prop['theNarrative'],
consequences=fake_prop['theConsequences'],
benefits=fake_prop['theBenefits'],
tCodes=[])
new_props.append(new_prop)
else:
self.close()
raise MissingParameterHTTPError(
param_names=['real_props', 'fake_props'])
return new_props
def inheritedTaskProperties(self, taskId, environmentName):
environmentId = self.getDimensionId(environmentName, 'environment')
dependencies = self.taskDependencies(taskId, environmentId)
personas = self.taskPersonas(taskId, environmentId)
assets = self.taskAssets(taskId, environmentId)
concs = self.taskConcernAssociations(taskId, environmentId)
narrative = self.taskNarrative(taskId, environmentId)
return TaskEnvironmentProperties(environmentName, dependencies,
personas, assets, concs, narrative)
def OnAddEnvironment(self, evt):
self.theSelectedIdx = evt.GetIndex()
environmentName = self.environmentList.GetItemText(self.theSelectedIdx)
self.theEnvironmentDictionary[
environmentName] = TaskEnvironmentProperties(environmentName)
self.environmentList.Select(self.theSelectedIdx)
self.personaList.setEnvironment(environmentName)
self.assetList.setEnvironment(environmentName)
self.caList.setEnvironment(environmentName)
self.narrativeCtrl.setEnvironment(environmentName)
self.personaList.DeleteAllItems()
self.assetList.DeleteAllItems()
self.caList.DeleteAllItems()
self.dependenciesCtrl.SetValue('')
self.narrativeCtrl.SetValue('')
self.consequencesCtrl.SetValue('')
self.benefitsCtrl.SetValue('')
self.narrativeCtrl.setCodes({})
self.consequencesCtrl.setCodes({})
self.benefitsCtrl.setCodes({})
self.dependenciesCtrl.Enable()
self.personaList.Enable()
self.assetList.Enable()
self.caList.Enable()
self.narrativeCtrl.Enable()
self.consequencesCtrl.Enable()
self.benefitsCtrl.Enable()
inheritedEnv = self.environmentList.inheritedEnvironment()
if (inheritedEnv != '' and self.theTaskId != None):
p = self.dbProxy.inheritedTaskProperties(self.theTaskId,
inheritedEnv)
self.theEnvironmentDictionary[environmentName] = p
self.dependenciesCtrl.SetValue(p.dependencies())
self.personaList.setEnvironment(environmentName)
self.assetList.setEnvironment(environmentName)
self.caList.setEnvironment(environmentName)
self.narrativeCtrl.setEnvironment(environmentName)
self.personaList.load(p.personas())
self.assetList.load(p.assets())
self.caList.load(p.concernAssociations())
self.narrativeCtrl.SetValue(p.narrative())
self.consequencesCtrl.SetValue(p.consequences())
self.benefitsCtrl.SetValue(p.benefits())
self.narrativeCtrl.setCodes(p.codes('narrative'))
self.consequencesCtrl.setCodes(p.codes('consequences'))
self.benefitsCtrl.setCodes(p.codes('benefits'))
self.dependenciesCtrl.Enable()
self.personaList.Enable()
self.assetList.Enable()
self.caList.Enable()
self.narrativeCtrl.Enable()
self.consequencesCtrl.Enable()
self.benefitsCtrl.Enable()
def environmentProperties(self):
if (self.theSelectedIdx != -1):
environmentName = self.environmentList.GetItemText(
self.theSelectedIdx)
envCodebook = {
'narrative': self.narrativeCtrl.codes(),
'consequences': self.consequencesCtrl.codes(),
'benefits': self.benefitsCtrl.codes()
}
self.theEnvironmentDictionary[
environmentName] = TaskEnvironmentProperties(
environmentName, self.dependenciesCtrl.GetValue(),
self.personaList.dimensions(), self.assetList.dimensions(),
self.caList.dimensions(), self.narrativeCtrl.GetValue(),
self.consequencesCtrl.GetValue(),
self.benefitsCtrl.GetValue(), envCodebook)
return self.theEnvironmentDictionary.values()
def endElement(self, name):
if name == 'persona':
p = PersonaParameters(self.theName, self.theActivities,
self.theAttitudes, self.theAptitudes,
self.theMotivations, self.theSkills,
self.theIntrinsic, self.theContextual,
self.theImage, self.isAssumptionPersona,
self.theType, self.theTags,
self.theEnvironmentProperties, {})
self.thePersonas.append(p)
self.resetPersonaAttributes()
elif name == 'persona_environment':
p = PersonaEnvironmentProperties(self.theEnvironmentName,
self.isDirect, self.theNarrative,
self.theRoles, {'narrative': {}})
self.theEnvironmentProperties.append(p)
self.resetPersonaEnvironmentAttributes()
elif name == 'external_document':
p = ExternalDocumentParameters(self.theName, self.theVersion,
self.theDate, self.theAuthors,
self.theDescription)
self.theExternalDocuments.append(p)
self.resetExternalDocumentAttributes()
elif name == 'document_reference':
p = DocumentReferenceParameters(self.theName, self.theDocument,
self.theContributor,
self.theExcerpt)
self.theDocumentReferences.append(p)
self.resetDocumentReferenceAttributes()
elif name == 'concept_reference':
p = ConceptReferenceParameters(self.theName, self.theConcept,
self.theObject, self.theDescription)
self.theConceptReferences.append(p)
self.resetConceptReferenceAttributes()
elif name == 'persona_characteristic':
p = PersonaCharacteristicParameters(
self.thePersona, self.theModalQualifier, self.theBvName,
self.theDefinition, self.theGrounds, self.theWarrants, [],
self.theRebuttals)
self.thePersonaCharacteristics.append(p)
self.resetPersonaCharacteristicAttributes()
elif name == 'task_characteristic':
p = TaskCharacteristicParameters(self.theTask,
self.theModalQualifier,
self.theDefinition,
self.theGrounds, self.theWarrants,
[], self.theRebuttals)
self.theTaskCharacteristics.append(p)
self.resetTaskCharacteristicAttributes()
elif name == 'task':
p = TaskParameters(self.theName, self.theCode, self.theObjective,
self.isAssumptionTask, self.theAuthor,
self.theTags, self.theEnvironmentProperties)
self.theTasks.append(p)
self.resetTaskAttributes()
elif name == 'task_environment':
p = TaskEnvironmentProperties(
self.theEnvironmentName, self.theDependencies,
self.theTaskPersonas, self.theConcerns,
self.theConcernAssociations, self.theNarrative,
self.theConsequences, self.theBenefits, {
'narrative': {},
'consequences': {},
'benefits': {}
})
self.theEnvironmentProperties.append(p)
self.resetTaskEnvironmentAttributes()
elif name == 'exception':
self.theCurrentStep.addException(
(self.theExcName, self.theExcType, self.theExcValue,
self.theExcCat, self.theDefinition))
elif name == 'step':
self.theCurrentStep.setTags(self.theTags)
self.theSteps.append(self.theCurrentStep)
self.theCurrentStep = None
elif name == 'usecase_environment':
p = UseCaseEnvironmentProperties(self.theEnvironmentName,
self.thePreconditions,
self.theSteps,
self.thePostconditions)
self.theEnvironmentProperties.append(p)
self.resetUseCaseEnvironmentAttributes()
elif name == 'usecase':
p = UseCaseParameters(self.theName, self.theAuthor, self.theCode,
self.theActors, self.theDescription,
self.theTags, self.theEnvironmentProperties)
self.theUseCases.append(p)
self.resetUseCaseAttributes()
elif name == 'activities':
self.inActivities = 0
elif name == 'attitudes':
self.inAttitudes = 0
elif name == 'aptitudes':
self.inAptitudes = 0
elif name == 'motivations':
self.inMotivations = 0
elif name == 'skills':
self.inSkills = 0
elif name == 'intrinsic':
self.inIntrinsic = 0
elif name == 'contextual':
self.inContextual = 0
elif name == 'narrative':
self.inNarrative = 0
elif name == 'excerpt':
self.inExcerpt = 0
elif name == 'description':
self.inDescription = 0
elif name == 'definition':
self.inDefinition = 0
elif name == 'dependencies':
self.inDependencies = 0
elif name == 'objective':
self.inObjective = 0
elif name == 'preconditions':
self.inPreconditions = 0
elif name == 'postconditions':
self.inPostconditions = 0
elif name == 'benefits':
self.inBenefits = 0
elif name == 'consequences':
self.inConsequences = 0
def testTask(self):
t = self.iTasks[0]
taskName = t["theName"]
taskTags = t["theTaskTags"]
taskShortCode = t["theShortCode"]
taskObjective = t["theObjective"]
taskAuthor = t["theAuthor"]
isAssumptionTask = int(t["isAssumption"])
tEnv = t["theEnvironments"][0]
envName = tEnv["theName"]
deps = tEnv["theDependencies"]
taskPersona = tEnv["theTaskPersonas"][0]["thePersona"]
taskDuration = tEnv["theTaskPersonas"][0]["theDuration"]
taskFreq = tEnv["theTaskPersonas"][0]["theFrequency"]
taskDemands = tEnv["theTaskPersonas"][0]["theDemands"]
taskGoalConflict = tEnv["theTaskPersonas"][0]["theGoalConflict"]
taskAssets = tEnv["theTaskAssets"]
taskConcerns = []
taskNarrative = tEnv["theNarrative"]
taskConsequences = tEnv["theConsequences"]
taskBenefits = tEnv["theBenefits"]
iteps = [
TaskEnvironmentProperties(envName, deps,
[(taskPersona, taskDuration, taskFreq,
taskDemands, taskGoalConflict)],
taskAssets, taskConcerns, taskNarrative,
taskConsequences, taskBenefits)
]
iTask = TaskParameters(taskName, taskShortCode, taskObjective,
isAssumptionTask, taskAuthor, taskTags, iteps)
b = Borg()
b.dbProxy.addTask(iTask)
theTasks = b.dbProxy.getTasks()
oTask = theTasks[self.iTasks[0]["theName"]]
self.assertEqual(iTask.name(), oTask.name())
self.assertEqual(iTask.tags(), oTask.tags())
self.assertEqual(iTask.shortCode(), oTask.shortCode())
self.assertEqual(iTask.objective(), oTask.objective())
self.assertEqual(iTask.assumption(), oTask.assumption())
self.assertEqual(iTask.author(), oTask.author())
self.assertEqual(iTask.environmentProperties()[0].personas(),
oTask.personas(envName, '', envName))
self.assertEqual(iTask.environmentProperties()[0].assets(),
oTask.assets(envName, ''))
self.assertEqual(iTask.environmentProperties()[0].narrative(),
oTask.narrative(envName, ''))
self.assertEqual(iTask.environmentProperties()[0].consequences(),
oTask.environmentProperties()[0].consequences())
self.assertEqual(iTask.environmentProperties()[0].benefits(),
oTask.environmentProperties()[0].benefits())
self.assertEqual(iTask.environmentProperties()[0].dependencies(),
oTask.environmentProperties()[0].dependencies())
self.assertEqual(oTask.usability(envName, ''), 5)
self.assertEqual(b.dbProxy.taskLoad(oTask.id(), 104), 5)
iTask.theName = 'Updated name'
iTask.setId(oTask.id())
b.dbProxy.updateTask(iTask)
theTasks = b.dbProxy.getTasks()
oTask = theTasks['Updated name']
self.assertEqual(oTask.name(), 'Updated name')
self.assertEqual(iTask.tags(), oTask.tags())
self.assertEqual(iTask.shortCode(), oTask.shortCode())
self.assertEqual(iTask.objective(), oTask.objective())
self.assertEqual(iTask.assumption(), oTask.assumption())
self.assertEqual(iTask.author(), oTask.author())
self.assertEqual(iTask.environmentProperties()[0].personas(),
oTask.environmentProperties()[0].personas())
self.assertEqual(iTask.environmentProperties()[0].personas(),
oTask.personas('Psychosis', '', ''))
self.assertEqual(
iTask.environmentProperties()[0].personas()[0][1],
list(oTask.personas('Psychosis', 'Maximise', ''))[0][1])
self.assertEqual(iTask.environmentProperties()[0].assets(),
oTask.environmentProperties()[0].assets())
self.assertEqual(iTask.environmentProperties()[0].assets(),
oTask.assets('Psychosis', ''))
self.assertEqual(iTask.environmentProperties()[0].assets(),
list(oTask.assets('', 'Maximise')))
self.assertEqual(iTask.environmentProperties()[0].narrative(),
oTask.environmentProperties()[0].narrative())
self.assertEqual(iTask.environmentProperties()[0].narrative(),
oTask.narrative('Psychosis', ''))
self.assertEqual(iTask.environmentProperties()[0].narrative(),
oTask.narrative('', 'Maximise'))
self.assertEqual(iTask.environmentProperties()[0].consequences(),
oTask.environmentProperties()[0].consequences())
self.assertEqual(iTask.environmentProperties()[0].benefits(),
oTask.environmentProperties()[0].benefits())
self.assertEqual(iTask.environmentProperties()[0].dependencies(),
oTask.environmentProperties()[0].dependencies())
self.assertEqual(iTask.environmentProperties()[0].dependencies(),
oTask.dependencies('Psychosis', ''))
self.assertEqual(iTask.environmentProperties()[0].dependencies(),
oTask.dependencies('', 'Maximise'))
b.dbProxy.deleteTask(oTask.id())
