def generateSystemFunctionalitySummary(self, structure):
features = list(
filter(lambda e: self.baseUri + 'Feature' in e.supertypes,
structure.entities))
funcreqs = list(
filter(
lambda e: self.baseUri + 'FunctionalRequirement' in e.
supertypes, structure.entities))
userstories = list(
filter(lambda e: self.baseUri + 'UserStory' in e.supertypes,
structure.entities))
usecases = list(
filter(lambda e: self.baseUri + 'UseCase' in e.supertypes,
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/SystemFunctionality.txt')
summary = template.format(path=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Feature section
expTemplate.addSection(
self.createSection(features,
'feature_section',
'Feature',
summary='',
priority=5).toDict())
#Fuctional requirements section
expTemplate.addSection(
self.createSection(funcreqs,
'func_req_section',
'Functional Requirements',
summary='',
priority=3).toDict())
#User story section
expTemplate.addSection(
self.createSection(userstories,
'user_story_section',
'User stories',
summary='',
priority=3).toDict())
#Use case section
expTemplate.addSection(
self.createSection(usecases,
'use_case_section',
'Use cases',
summary='',
priority=3).toDict())
return expTemplate
def generateSystemPatternsDetailedSummary(self, structure, viewType):
template = explanationHelper.openText(
'static/explanationTemplates/PatternsInSystemDetailed.txt')
patternName = self.styledName('architectural patterns', 'class-font',
self.baseUri + 'ArchitecturalPattern')
roleName = self.styledName('roles', 'class-font',
self.baseUri + 'Role')
summary = template.format(view_type=viewType,
architectural_pattern=patternName,
structural_entities='structural entities',
role=roleName,
path=self.classesToText(structure.entities))
return self.generateGeneralSummary(structure, summary)
def generateSpecificSystemPatternsDetailedSummary(self, structure,
mainEntity):
noStylePatternName = explanationHelper.getNameOfEntity(mainEntity)
patternName = self.styledName(noStylePatternName, 'class-font',
self.baseUri + 'ArchitecturalPattern')
roleName = self.styledName('roles', 'class-font',
self.baseUri + 'Role')
template = explanationHelper.openText(
'static/explanationTemplates/SpecificPatternInSystemDetailed.txt')
summary = template.format(pattern=patternName,
no_style_pattern=noStylePatternName,
role=roleName,
structural_entities='structural entities',
path=self.classesToText(structure.entities))
return self.generateGeneralSummary(structure, summary)
def generateOverviewFeatureImplementationSummary(self, mainEntityUri,
structure):
mainEntity = [
entity for entity in structure.entities
if entity.uri == mainEntityUri
][0]
impl = list(
filter(
lambda e: self.baseUri + 'ImplementationClass' in e.supertypes,
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/OverviewViewImplementation.txt')
summary = template.format(
feature_name=self.styledName(
explanationHelper.getNameOfEntity(mainEntity), 'class-font',
mainEntity.type),
no_style_feature_name=explanationHelper.getNameOfEntity(
mainEntity),
path=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Feature section
sectionFeatureOverview = ''
expTemplate.addSection(
self.createSection([mainEntity],
'feature_section',
'Feature',
summary=sectionFeatureOverview,
priority=5).toDict())
#Implmentation section
sectionImplOverview = ''
sectionImplOverview = sectionImplOverview.format(
main_entity=explanationHelper.getNameOfEntity(mainEntity))
expTemplate.addSection(
self.createSection(impl,
'impl_section',
'Implementation classes',
summary=sectionImplOverview,
priority=3).toDict())
return expTemplate
def generatePopupFigureDescription(self, figureUri):
figureEntity = ontologyStructureModel.Entity(figureUri)
template = explanationHelper.openText(
'static/explanationTemplates/FigureSummary.txt')
relatedEntityUris = [
ontologyStructureModel.Entity(entity[1])
for entity in self.informationRetriever.getRelations(
figureUri, self.baseUri + 'models')
]
summary = template.format(
classes=self.classesToText(relatedEntityUris))
question = {'sub': 'View diagrams', 'orginial': ''}
figureid = 'popup_' + explanationHelper.diagramUriToFileName(
explanationHelper.getNameFromUri(figureUri))
figuretitle = explanationHelper.getNameOfEntity(figureEntity)
figureSummary = ''
entityid = 'popup_entity_overview_' + explanationHelper.diagramUriToFileName(
explanationHelper.getNameFromUri(figureUri))
entitySummary = ''
relatedEntities = relatedEntityUris
figureSection = sectionModel.Section(
figureid,
figuretitle,
figureSummary,
priority=5,
sectionTextContent=[
(explanationHelper.getNameFromUri(content[0]), content[1])
for content in figureEntity.dataTypeProperties
])
entitySection = self.createSection(relatedEntities, entityid,
'Entities related to diagram',
entitySummary)
template = sectionModel.Template(question, summary)
template.addSection(figureSection.toDict())
template.addSection(entitySection.toDict())
return template
def generateSystemPatternsOverviewSummary(self,
structure,
mainEntity=None):
template = explanationHelper.openText(
'static/explanationTemplates/PatternsInSystemOverview.txt')
if mainEntity:
pattern = explanationHelper.getNameOfEntity(mainEntity)
pluralNumber = 1
else:
pattern = 'architectural patterns'
pluralNumber = 2
summary = template.format(
path=self.classesToText(structure.entities),
architectural_patterns=self.styledName(
pattern, 'class-font', self.baseUri + 'ArchitecturalPattern'),
roles=self.styledName('roles', 'class-font',
self.baseUri + 'Role'),
plural=self.pluralEngine.plural('its', pluralNumber))
return self.generateGeneralSummary(structure, summary)
def generatePatternFeatureImplementationSummary(self, mainEntityUri,
structure):
mainEntity = ontologyStructureModel.Entity(mainEntityUri)
impl = list(
filter(lambda e: e.type == self.baseUri + 'ImplementationClass',
structure.entities))
role = list(
filter(lambda e: e.type == self.baseUri + 'Role',
structure.entities))
arch = list(
filter(lambda e: e.type == self.baseUri + 'ArchitecturalPattern',
structure.entities))
developmentClasses = list(
filter(lambda e: self.baseUri + 'DevelopmentClass' in e.supertypes,
structure.entities))
developmentClassPackages = list(
filter(
lambda e: self.baseUri + 'DevelopmentClassPackage' in e.
supertypes, structure.entities))
developmentPackages = list(
filter(
lambda e: self.baseUri + 'DevelopmentPackage' in e.supertypes,
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/PatternViewImplementation.txt')
summary = template.format(
impl_class=self.styledName('Implementation classes', 'class-font',
self.baseUri + 'ImplementationClass'),
arch_patt=self.styledName('Architectural patterns', 'class-font',
self.baseUri + 'ArchitecturalPattern'),
path_inbetween=self.classesToText(structure.entities))
question = self.getQuestion(summary)
sectionImplOverview = ''
sectionImplOverview = sectionImplOverview.format(
main_entity=explanationHelper.getNameOfEntity(mainEntity))
expTemplate = sectionModel.Template(question, summary)
implSection = self.createSection(impl,
'impl_section',
'Implementation classes',
summary=sectionImplOverview,
priority=4)
if developmentClasses:
expTemplate.addSection(
self.createSection(developmentClasses,
'developmentClass_section',
'Development classes',
summary=self.sectionSummary(
developmentClasses[0].type),
priority=2).toDict())
if developmentClassPackages:
expTemplate.addSection(
self.createSection(developmentClassPackages,
'developmentClassPackage_section',
'Development class packages',
summary=self.sectionSummary(
developmentClassPackages[0].type),
priority=2).toDict())
if developmentPackages:
expTemplate.addSection(
self.createSection(developmentPackages,
'developmentPackage_section',
'Development packages',
summary=self.sectionSummary(
developmentPackages[0].type),
priority=2).toDict())
sectionRoleOverview = ''
roleSection = self.createSection(role,
'role_section',
'Roles',
summary=sectionRoleOverview,
priority=2)
sectionArchOverview = ''
archSection = self.createSection(arch,
'arch_section',
'Architectural patterns',
summary=sectionArchOverview,
priority=1)
expTemplate.addSection(implSection.toDict())
expTemplate.addSection(roleSection.toDict())
expTemplate.addSection(archSection.toDict())
return expTemplate
def generateDetailedFeatureImplementationSummary(self, mainEntityUri,
structure):
# Setup the summary
main_entity = [
entity for entity in structure.entities
if entity.uri == mainEntityUri
][0]
requirements = list(
filter(lambda e: e.type == self.baseUri + 'FunctionalRequirement',
structure.entities))
logicalClasses = list(
filter(lambda e: self.baseUri + 'LogicalClass' in e.supertypes,
structure.entities))
developmentClasses = list(
filter(lambda e: self.baseUri + 'DevelopmentClass' in e.supertypes,
structure.entities))
developmentClassPackages = list(
filter(
lambda e: self.baseUri + 'DevelopmentClassPackage' in e.
supertypes, structure.entities))
developmentPackages = list(
filter(lambda e: self.baseUri + 'Package' in e.supertypes,
structure.entities))
implementation = list(
filter(
lambda e: self.baseUri + 'ImplementationClass' in e.supertypes,
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/DetailedViewImplementation.txt')
entityName = explanationHelper.getNameOfEntity(main_entity)
summary = template.format(
no_style_feature_name=entityName,
feature_name=self.styledName(
explanationHelper.getNameOfEntity(main_entity),
'entity-font',
entityType=main_entity.type),
target_type_name=self.styledName('implementation',
'class-font',
entityType=self.baseUri +
'ImplementationClass'),
path_inbetween=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Logical section
logicalSection = self.createSection(logicalClasses,
'logical_section',
'Logical classes',
summary=self.sectionSummary(
logicalClasses[0].type),
priority=3)
overviewDiagrams = self.getOverviewDiagrams(structure,
'LogicalStructure')
overviewIdCounter = 0
for key, value in overviewDiagrams.items():
dummySection = sectionModel.Section(
'overview' + str(overviewIdCounter),
value['name'],
sectionSummary=value['description'],
sectionDiagrams=[{
'uri': key,
'caption': value['caption']
}])
overviewIdCounter += 1
overviewSectionSummary = 'This section presents and describes diagrams that encapsulate all of the logical classes found in this explanation.'
overviewSection = sectionModel.Section(
'logical_overview',
'Overview',
sectionSummary=overviewSectionSummary,
priority=99)
overviewSection.addChild(dummySection.toDict())
logicalSection.addChild(overviewSection.toDict())
expTemplate.addSection(logicalSection.toDict())
#Implementation section
expTemplate.addSection(
self.createSection(implementation,
'implementation_section',
'Implementation classes',
summary=self.sectionSummary(
implementation[0].type),
priority=1).toDict())
#Development structure section
if developmentClasses:
expTemplate.addSection(
self.createSection(developmentClasses,
'developmentClass_section',
'Development classes',
summary=self.sectionSummary(
developmentClasses[0].type),
priority=2).toDict())
#Development structure section
if developmentClassPackages:
expTemplate.addSection(
self.createSection(developmentClassPackages,
'developmentClassPackage_section',
'Development class packages',
summary=self.sectionSummary(
developmentClassPackages[0].type),
priority=2).toDict())
#Development structure section
if developmentPackages:
expTemplate.addSection(
self.createSection(developmentPackages,
'developmentPackage_section',
'Development packages',
summary=self.sectionSummary(
developmentPackages[0].type),
priority=2).toDict())
#Requirements section
expTemplate.addSection(
self.createSection(requirements,
'requirements_section',
'Functional requirements',
summary=self.sectionSummary(
requirements[0].type),
priority=4).toDict())
#Feature section
expTemplate.addSection(
self.createSection([main_entity],
'feature_section',
'Feature',
summary=self.sectionSummary(main_entity.type),
priority=5).toDict())
return expTemplate.toDict()
def generateRationaleSummary(self, pattern, structure):
pattern_entity = [
entity for entity in structure.entities if entity.uri == pattern
][0]
patterns = list(
filter(
lambda e: self.baseUri + 'ArchitecturalPattern' in e.
supertypes, structure.entities))
designOptions = list(
filter(lambda e: self.baseUri + 'DesignOption' in e.supertypes,
structure.entities))
arguments = list(
filter(lambda e: e.type == self.baseUri + 'Argument',
structure.entities))
assumptions = list(
filter(lambda e: e.type == self.baseUri + 'Assumption',
structure.entities))
constraints = list(
filter(lambda e: e.type == self.baseUri + 'Constraint',
structure.entities))
nonFuncReqs = list(
filter(
lambda e: e.type == self.baseUri + 'NonFunctionalRequirement',
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/RationaleOfArchitecture.txt')
summary = template.format(
no_style_arch_patt=explanationHelper.getNameOfEntity(
pattern_entity),
arch_patt=self.styledName(
explanationHelper.getNameOfEntity(pattern_entity),
'class-font', pattern_entity.type),
path=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Pattern section
sectionDOOverview = ''
expTemplate.addSection(
self.createSection(patterns,
'pattern_section',
'Architectural patterns',
summary=sectionDOOverview,
priority=5).toDict())
#Choice section
sectionDOOverview = ''
expTemplate.addSection(
self.createSection(designOptions,
'design_option_section',
'Design options',
summary=sectionDOOverview,
priority=4).toDict())
#Arguments section
sectionArgOverview = ''
expTemplate.addSection(
self.createSection(arguments,
'arguments_section',
'Arguments',
summary=sectionArgOverview,
priority=3).toDict())
#Constraint section
sectionConOverview = ''
expTemplate.addSection(
self.createSection(constraints,
'constraint_section',
'Constraints',
summary=sectionConOverview,
priority=2).toDict())
#Assumption section
sectionAssOverview = ''
expTemplate.addSection(
self.createSection(assumptions,
'assumption_section',
'Assumptions',
summary=sectionAssOverview,
priority=1).toDict())
#Non functional section
sectionNonFuncOverview = ''
expTemplate.addSection(
self.createSection(nonFuncReqs,
'non_functional_section',
'Non-functional requirements',
summary=sectionNonFuncOverview,
priority=0).toDict())
return expTemplate.toDict()
def generateFunctionalBehaviorSummary(self, featureUri, structure):
feature_entity = [
entity for entity in structure.entities if entity.uri == featureUri
][0]
requirements = list(
filter(lambda e: e.type == self.baseUri + 'FunctionalRequirement',
structure.entities))
userstories = list(
filter(lambda e: self.baseUri + 'UserStory' == e.type,
structure.entities))
usecases = list(
filter(lambda e: self.baseUri + 'UseCase' == e.type,
structure.entities))
diagrams = list(
filter(lambda e: e.type == self.baseUri + 'Diagram',
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/BehaviorOfFeature.txt')
summary = template.format(
feature_name=self.styledName(
explanationHelper.getNameOfEntity(feature_entity),
'entity-font',
entityType=feature_entity.type),
no_style_feature_name=explanationHelper.getNameOfEntity(
feature_entity),
point_of_view='Functional point of view',
path=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Feature section
expTemplate.addSection(
self.createSection([feature_entity],
'feature_section',
'Features',
summary='',
priority=5).toDict())
#Requirements section
expTemplate.addSection(
self.createSection(requirements,
'requirements_section',
'Requirements',
summary='',
priority=4).toDict())
#UserStory section
expTemplate.addSection(
self.createSection(usecases,
'use_case_section',
'Use cases',
summary='',
priority=3).toDict())
#Usecase section
expTemplate.addSection(
self.createSection(userstories,
'user_story_section',
'User stories',
summary='',
priority=2).toDict())
#Diagram section
expTemplate.addSection(
self.createSection(diagrams,
'diagram_section',
'Diagram entities',
summary='',
priority=1).toDict())
return expTemplate.toDict()
def generateBehaviorSummary(self, featureUri, structure, viewType):
if viewType == 'functional':
return self.generateFunctionalBehaviorSummary(
featureUri, structure)
if viewType == 'logical':
structureTypeUri = 'LogicalStructure'
behaviorTypeUri = 'LogicalBehavior'
viewTypeUri = 'Logical'
elif viewType == 'development':
structureTypeUri = 'DevelopmentStructure'
behaviorTypeUri = 'DevelopmentBehavior'
viewTypeUri = 'Development'
elif viewType == 'ui':
structureTypeUri = 'UIStructure'
behaviorTypeUri = 'UIBehavior'
viewTypeUri = 'UI'
else:
return {}
if (not structure.entities):
question = self.getQuestion(
explanationHelper.openText(
'static/explanationTemplates/BehaviorOfFeature.txt'))
return sectionModel.Template(
question,
'<font style="color:red;font-weight:bold;font-size:20">No documented data of the '
+ viewType + ' behavior of this feature was found.</font>')
feature_entity = [
entity for entity in structure.entities if entity.uri == featureUri
][0]
requirements = list(
filter(lambda e: e.type == self.baseUri + 'FunctionalRequirement',
structure.entities))
structures = list(
filter(lambda e: self.baseUri + structureTypeUri in e.supertypes,
structure.entities))
behavior = list(
filter(lambda e: self.baseUri + behaviorTypeUri in e.supertypes,
structure.entities))
diagrams = list(
filter(lambda e: e.type == self.baseUri + 'Diagram',
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/BehaviorOfFeature.txt')
summary = template.format(
feature_name=self.styledName(
explanationHelper.getNameOfEntity(feature_entity),
'entity-font',
entityType=feature_entity.type),
no_style_feature_name=explanationHelper.getNameOfEntity(
feature_entity),
point_of_view=self.styledName(viewType + ' point of view',
'class-font',
entityType=self.baseUri +
viewTypeUri),
path=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Feature section
sectionReqOverview = ''
expTemplate.addSection(
self.createSection([feature_entity],
'features_section',
'Features',
summary=sectionReqOverview,
priority=4).toDict())
#Requirements section
sectionReqOverview = ''
expTemplate.addSection(
self.createSection(requirements,
'requirements_section',
'Requirement',
summary=sectionReqOverview,
priority=4).toDict())
#Structures section
sectionStructOverview = ''
expTemplate.addSection(
self.createSection(structures,
'structures_section',
'Structure entities',
summary=sectionStructOverview,
priority=3).toDict())
#Behavior section
sectionBehOverview = ''
expTemplate.addSection(
self.createSection(behavior,
'behavior_section',
'Behavior entities',
summary=sectionBehOverview,
priority=2).toDict())
#Diagrams section
sectionDiaOverview = ''
expTemplate.addSection(
self.createSection(diagrams,
'diagram_section',
'Diagrams',
summary=sectionDiaOverview,
priority=1).toDict())
return expTemplate.toDict()
def generateFeatureRoleSummary(self, featureUri, structure):
feature_entity = [
entity for entity in structure.entities if entity.uri == featureUri
][0]
requirements = list(
filter(lambda e: e.type == self.baseUri + 'FunctionalRequirement',
structure.entities))
use_cases = list(
filter(lambda e: e.type == self.baseUri + 'UseCase',
structure.entities))
user_stories = list(
filter(lambda e: e.type == self.baseUri + 'UserStory',
structure.entities))
template = explanationHelper.openText(
'static/explanationTemplates/FeatureRole.txt')
summary = template.format(
no_style_feature_name=explanationHelper.getNameOfEntity(
feature_entity),
feature_name=self.styledName(
explanationHelper.getNameOfEntity(feature_entity),
'class-font', feature_entity.type),
path=self.classesToText(structure.entities))
question = self.getQuestion(summary)
expTemplate = sectionModel.Template(question, summary)
#Features section
expTemplate.addSection(
self.createSection([feature_entity],
'features_section',
'Feature',
summary='',
priority=3).toDict())
#Requirements section
expTemplate.addSection(
self.createSection(requirements,
'requirements_section',
'FunctionalRequirement',
summary='',
priority=3).toDict())
#Use cases section
expTemplate.addSection(
self.createSection(use_cases,
'use_case_section',
'UseCase',
summary='',
priority=2).toDict())
#User story section
expTemplate.addSection(
self.createSection(user_stories,
'user_story_section',
'UserStory',
summary='',
priority=1).toDict())
return expTemplate.toDict()
def generateGeneralManualExplanation(self, structure):
template = explanationHelper.openText(
'static/explanationTemplates/GeneralManualExplanation.txt')
summary = template.format(path=self.classesToText(structure.entities))
return self.generateGeneralSummary(structure, summary)