diff --git a/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventDao.java b/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventDao.java index c863bf0..253eca2 100755 --- a/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventDao.java +++ b/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventDao.java @@ -2,7 +2,6 @@ import cz.cvut.kbss.analysis.config.conf.PersistenceConf; import cz.cvut.kbss.analysis.exception.PersistenceException; -import cz.cvut.kbss.analysis.model.System; import cz.cvut.kbss.analysis.model.*; import cz.cvut.kbss.analysis.model.diagram.Rectangle; import cz.cvut.kbss.analysis.service.IdentifierService; @@ -14,15 +13,10 @@ import org.springframework.stereotype.Repository; import java.net.URI; -import java.util.*; @Repository public class FaultEventDao extends NamedEntityDao { - public final static URI DERIVED_FROM_PROP = URI.create(Vocabulary.s_p_is_derived_from); - public final static URI FTA_EVENT_TYPE_PROP = URI.create(Vocabulary.s_p_fault_event_type); - public final static URI IS_MANIFESTED_BY_PROP = URI.create(Vocabulary.s_p_is_manifested_by); - @Autowired protected FaultEventDao(EntityManager em, PersistenceConf config, IdentifierService identifierService) { super(FaultEvent.class, em, config, identifierService); @@ -72,152 +66,4 @@ public Rectangle update(Rectangle rect){ throw new PersistenceException(e); } } - - public Optional findEvent(URI id){ - Objects.requireNonNull(id); - try { - EntityDescriptor entityDescriptor = getEntityDescriptor(id); - return Optional.ofNullable(em.find(Event.class, id, entityDescriptor)); - } catch (RuntimeException e) { - throw new PersistenceException(e); - } - } - - public void loadManagedSupertypesOrCreate(FaultEvent faultEvent, NamedEntity system, URI context){ - if(faultEvent.getSupertypes() == null || faultEvent.getSupertypes().isEmpty()) - return; - Set newSupertypes = new HashSet<>(); - Set managedSupertypes = new HashSet<>(); - Set unmanagedSupertypes = faultEvent.getSupertypes(); - faultEvent.setSupertypes(managedSupertypes); - - for(Event event : unmanagedSupertypes){ - Optional opt = event.getUri() != null ? - findEvent(event.getUri()) : - Optional.ofNullable(null); - if(opt.isPresent()) - managedSupertypes.add(opt.get()); - else - newSupertypes.add(event); - } - - if(newSupertypes.isEmpty()) - return; - - System managedSystem = em.find(System.class, system.getUri()); - - EntityDescriptor entityDescriptor = new EntityDescriptor(context); - for(Event evt : newSupertypes){ - FailureMode fm = new FailureMode(); - fm.setName(evt.getName() + " failure mode"); - fm.setItem(managedSystem); - evt.setBehavior(fm); - - em.persist(evt, entityDescriptor); - managedSupertypes.add(evt); - } - } - - /** - * Replaces the supertypes of the faultEvent argument, if any, with their managed versions - * @param faultEvent - */ - public void loadManagedSupertypes(FaultEvent faultEvent){ - if(faultEvent.getSupertypes() != null) { - Set managedSupertypes = new HashSet<>(); - for(Event event : faultEvent.getSupertypes()){ - findEvent(event.getUri()).ifPresent(managedSupertypes::add); - } - faultEvent.setSupertypes(managedSupertypes); - } - } - - public List getFaultEventRootWithSupertype(URI supertype){ - try{ - return em.createNativeQuery( - """ - SELECT DISTINCT ?faultEvent ?faultTree WHERE{ - ?faultEvent ?derivedFrom ?supertype. - ?faultEvent ?ftaEventTypeProp ?ftaEventType. - ?faultEvent a ?type. - ?faultTree ?isManifestedByProp ?faultEvent - }""", "FaultEventReference") - .setParameter("derivedFrom", DERIVED_FROM_PROP) - .setParameter("supertype", supertype) - .setParameter("ftaEventTypeProp", FTA_EVENT_TYPE_PROP) - .setParameter("type", this.typeUri) - .setParameter("isManifestedByProp", IS_MANIFESTED_BY_PROP) - .getResultList(); - }catch (RuntimeException e){ - throw new PersistenceException(e); - } - } - - public List getTopFaultEvents(URI systemUri) { - try{ - List ret = em.createNativeQuery(""" - PREFIX fta: - SELECT ?uri ?name ?componentName ?eventType { - ?uri a fta:fha-fault-event ; - fta:name ?name ; - fta:is-manifestation-of/fta:has-component/((^fta:has-part-component)+) ?system ; - fta:is-derived-from ?generalEvent . - - FILTER NOT EXISTS{ - ?system1 fta:has-part-component ?system. - } - - ?generalEvent fta:is-manifestation-of ?fm . - ?fm fta:has-component ?component . - - ?component fta:name ?componentLabel ; - fta:ata-code ?code . - BIND(CONCAT(str(?code), " - ", str(?componentLabel)) as ?componentName) - BIND("INTERMEDIATE" as ?eventType) - } - """, "FaultEventSummary") - .setParameter("system", systemUri) - .getResultList(); - List ret1 = ret.stream().map(fe -> fe.asEntity(FaultEventType.class)).toList(); - return ret1; - }catch (RuntimeException e){ - throw new PersistenceException(e); - } - } - - public List getAllFaultEvents(URI systemUri) { - try{ - List ret = em.createNativeQuery(""" - PREFIX fta: - SELECT ?uri ?name ?componentName ?eventType { - ?uri a ?eventClass. - FILTER(?eventClass in (fta:fha-fault-event, fta:fault-event-type)) - ?uri fta:name ?name ; - fta:is-manifestation-of/fta:has-component/((^fta:has-part-component)+) ?system ; - fta:is-derived-from ?generalEvent . - - - FILTER NOT EXISTS{ - ?system1 fta:has-part-component ?system. - } - - ?generalEvent fta:is-manifestation-of ?fm . - ?fm fta:has-component ?component . - - ?component fta:name ?componentLabel ; - fta:ata-code ?code . - BIND(CONCAT(str(?code), " - ", str(?componentLabel)) as ?componentName) - - BIND(IF(?eventClass = fta:fha-fault-event, "INTERMEDIATE", "BASIC") as ?eventType) - } - """, "FaultEventSummary") - .setParameter("system", systemUri) - .getResultList(); - - List ret1 = ret.stream().map(fe -> fe.asEntity(FaultEventType.class)).toList(); - return ret1; - }catch (RuntimeException e){ - throw new PersistenceException(e); - } - } } diff --git a/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventTypeDao.java b/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventTypeDao.java new file mode 100644 index 0000000..27020a3 --- /dev/null +++ b/src/main/java/cz/cvut/kbss/analysis/dao/FaultEventTypeDao.java @@ -0,0 +1,115 @@ +package cz.cvut.kbss.analysis.dao; + +import cz.cvut.kbss.analysis.config.conf.PersistenceConf; +import cz.cvut.kbss.analysis.exception.PersistenceException; +import cz.cvut.kbss.analysis.model.FaultEventReference; +import cz.cvut.kbss.analysis.model.FaultEventType; +import cz.cvut.kbss.analysis.model.FaultEventTypeSummary; +import cz.cvut.kbss.analysis.service.IdentifierService; +import cz.cvut.kbss.analysis.util.Vocabulary; +import cz.cvut.kbss.jopa.model.EntityManager; +import org.springframework.stereotype.Repository; + +import java.net.URI; +import java.util.List; + +@Repository +public class FaultEventTypeDao extends NamedEntityDao { + + public final static URI DERIVED_FROM_PROP = URI.create(Vocabulary.s_p_is_derived_from); + public final static URI FTA_EVENT_TYPE_PROP = URI.create(Vocabulary.s_p_fault_event_type); + public final static URI IS_MANIFESTED_BY_PROP = URI.create(Vocabulary.s_p_is_manifested_by); + + public FaultEventTypeDao(EntityManager em, PersistenceConf config, IdentifierService identifierService) { + super(FaultEventType.class, em, config, identifierService); + } + + public List getFaultEventRootWithSupertype(URI supertype){ + try{ + return em.createNativeQuery( + """ + SELECT DISTINCT ?faultEvent ?faultTree WHERE{ + ?faultEvent ?derivedFrom ?supertype. + ?faultEvent ?ftaEventTypeProp ?ftaEventType. + ?faultEvent a ?type. + ?faultTree ?isManifestedByProp ?faultEvent + }""", "FaultEventReference") + .setParameter("derivedFrom", DERIVED_FROM_PROP) + .setParameter("supertype", supertype) + .setParameter("ftaEventTypeProp", FTA_EVENT_TYPE_PROP) + .setParameter("type", this.typeUri) + .setParameter("isManifestedByProp", IS_MANIFESTED_BY_PROP) + .getResultList(); + }catch (RuntimeException e){ + throw new PersistenceException(e); + } + } + + public List getTopFaultEvents(URI systemUri) { + try{ + List ret = em.createNativeQuery(""" + PREFIX fta: + SELECT ?uri ?name ?componentName ?eventType { + ?uri a fta:fha-fault-event ; + fta:name ?name ; + fta:is-manifestation-of/fta:has-component/((^fta:has-part-component)+) ?system ; + fta:is-derived-from ?generalEvent . + + FILTER NOT EXISTS{ + ?system1 fta:has-part-component ?system. + } + + ?generalEvent fta:is-manifestation-of ?fm . + ?fm fta:has-component ?component . + + ?component fta:name ?componentLabel ; + fta:ata-code ?code . + BIND(CONCAT(str(?code), " - ", str(?componentLabel)) as ?componentName) + BIND("INTERMEDIATE" as ?eventType) + } + """, "FaultEventSummary") + .setParameter("system", systemUri) + .getResultList(); + List ret1 = ret.stream().map(fe -> fe.asEntity(FaultEventType.class)).toList(); + return ret1; + }catch (RuntimeException e){ + throw new PersistenceException(e); + } + } + + public List getAllFaultEvents(URI systemUri) { + try{ + List ret = em.createNativeQuery(""" + PREFIX fta: + SELECT ?uri ?name ?componentName ?eventType { + ?uri a ?eventClass. + FILTER(?eventClass in (fta:fha-fault-event, fta:fault-event-type)) + ?uri fta:name ?name ; + fta:is-manifestation-of/fta:has-component/((^fta:has-part-component)+) ?system ; + fta:is-derived-from ?generalEvent . + + + FILTER NOT EXISTS{ + ?system1 fta:has-part-component ?system. + } + + ?generalEvent fta:is-manifestation-of ?fm . + ?fm fta:has-component ?component . + + ?component fta:name ?componentLabel ; + fta:ata-code ?code . + BIND(CONCAT(str(?code), " - ", str(?componentLabel)) as ?componentName) + + BIND(IF(?eventClass = fta:fha-fault-event, "INTERMEDIATE", "BASIC") as ?eventType) + } + """, "FaultEventSummary") + .setParameter("system", systemUri) + .getResultList(); + + List ret1 = ret.stream().map(fe -> fe.asEntity(FaultEventType.class)).toList(); + return ret1; + }catch (RuntimeException e){ + throw new PersistenceException(e); + } + } +} diff --git a/src/main/java/cz/cvut/kbss/analysis/service/FaultEventRepositoryService.java b/src/main/java/cz/cvut/kbss/analysis/service/FaultEventRepositoryService.java index 3be2a89..be7b29f 100755 --- a/src/main/java/cz/cvut/kbss/analysis/service/FaultEventRepositoryService.java +++ b/src/main/java/cz/cvut/kbss/analysis/service/FaultEventRepositoryService.java @@ -1,6 +1,7 @@ package cz.cvut.kbss.analysis.service; import cz.cvut.kbss.analysis.dao.FaultEventDao; +import cz.cvut.kbss.analysis.dao.FaultEventTypeDao; import cz.cvut.kbss.analysis.dao.FaultTreeDao; import cz.cvut.kbss.analysis.dao.GenericDao; import cz.cvut.kbss.analysis.exception.LogicViolationException; @@ -35,13 +36,17 @@ public class FaultEventRepositoryService extends BaseRepositoryService referencedRoots = faultEventDao.getFaultEventRootWithSupertype(supertype.getUri()); + List referencedRoots = faultEventTypeDao.getFaultEventRootWithSupertype(supertype.getUri()); if(referencedRoots == null || referencedRoots.isEmpty()) return; @@ -169,7 +174,7 @@ public void updateChildrenSequence(URI faultEventUri, List childrenSequence @Override protected void preUpdate(FaultEvent instance) { if(instance.getSupertypes() != null && !instance.getSupertypes().isEmpty()) - faultEventDao.loadManagedSupertypes(instance); + faultEventTypeService.loadManagedSupertypes(instance); super.preUpdate(instance); } @@ -203,12 +208,12 @@ protected void setChange(FaultEvent instance){ } public List getTopFaultEvents(URI systemUri) { - return faultEventDao.getTopFaultEvents(systemUri); + return faultEventTypeDao.getTopFaultEvents(systemUri); } public List getAllFaultEvents(URI faultTreeUri) { FaultTree ftSummary = faultTreeDao.findSummary(faultTreeUri); - List ret = faultEventDao.getAllFaultEvents(ftSummary.getSystem().getUri()); + List ret = faultEventTypeDao.getAllFaultEvents(ftSummary.getSystem().getUri()); Set typesToRemove = Optional.ofNullable(ftSummary.getManifestingEvent()).map(r -> r.getSupertypes()) .filter(s -> s !=null && !s.isEmpty()) .map(s -> s.stream().map(t -> t.getUri()).collect(Collectors.toSet())) diff --git a/src/main/java/cz/cvut/kbss/analysis/service/FaultEventTypeService.java b/src/main/java/cz/cvut/kbss/analysis/service/FaultEventTypeService.java new file mode 100644 index 0000000..b2a4d3f --- /dev/null +++ b/src/main/java/cz/cvut/kbss/analysis/service/FaultEventTypeService.java @@ -0,0 +1,89 @@ +package cz.cvut.kbss.analysis.service; + +import cz.cvut.kbss.analysis.dao.FaultEventTypeDao; +import cz.cvut.kbss.analysis.dao.GenericDao; +import cz.cvut.kbss.analysis.dao.SystemDao; +import cz.cvut.kbss.analysis.model.*; +import cz.cvut.kbss.analysis.model.System; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.net.URI; +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; + +@Service +@Slf4j +public class FaultEventTypeService extends BaseRepositoryService { + + private final FaultEventTypeDao eventTypeDao; + private final SystemDao systemDao; + + public FaultEventTypeService(FaultEventTypeDao eventTypeDao, SystemDao systemDao) { + super(null); + this.eventTypeDao = eventTypeDao; + this.systemDao = systemDao; + } + + @Transactional + public void loadManagedSupertypesOrCreate(FaultEvent faultEvent, NamedEntity system, URI context){ + if(faultEvent.getSupertypes() == null || faultEvent.getSupertypes().isEmpty()) + return; + Set newSupertypes = new HashSet<>(); + Set managedSupertypes = new HashSet<>(); + Set unmanagedSupertypes = faultEvent.getSupertypes(); + faultEvent.setSupertypes(managedSupertypes); + + for(Event event : unmanagedSupertypes){ + Optional opt = event.getUri() != null ? + eventTypeDao.find(event.getUri()) : + Optional.ofNullable(null); + if(opt.isPresent()) + managedSupertypes.add(opt.get()); + else + newSupertypes.add(event); + } + + if(newSupertypes.isEmpty()) + return; + + System managedSystem = systemDao.find(system.getUri()).orElse(null); + + for(Event evt : newSupertypes){ + FailureMode fm = new FailureMode(); + fm.setName(evt.getName() + " failure mode"); + fm.setItem(managedSystem); + evt.setBehavior(fm); + evt.setContext(context); + eventTypeDao.persist((FaultEventType) evt); + managedSupertypes.add(evt); + } + } + + /** + * Replaces the supertypes of the faultEvent argument, if any, with their managed versions + * @param faultEvent + */ + public void loadManagedSupertypes(FaultEvent faultEvent){ + if(faultEvent.getSupertypes() != null) { + Set managedSupertypes = new HashSet<>(); + for(Event event : faultEvent.getSupertypes()){ + eventTypeDao.find(event.getUri()).ifPresent(managedSupertypes::add); + } + faultEvent.setSupertypes(managedSupertypes); + } + } + + + + @Override + protected GenericDao getPrimaryDao() { + return eventTypeDao; + } + + @Override + protected void validate(FaultEventType instance) { + } +} diff --git a/src/main/java/cz/cvut/kbss/analysis/service/FaultTreeRepositoryService.java b/src/main/java/cz/cvut/kbss/analysis/service/FaultTreeRepositoryService.java index 2c9a7bd..46d3001 100755 --- a/src/main/java/cz/cvut/kbss/analysis/service/FaultTreeRepositoryService.java +++ b/src/main/java/cz/cvut/kbss/analysis/service/FaultTreeRepositoryService.java @@ -41,6 +41,8 @@ public class FaultTreeRepositoryService extends ComplexManagedEntityRepositorySe private final FaultEventDao faultEventDao; private final OperationalDataFilterService operationalDataFilterService; private final FailureModeDao failureModeDao; + private final FaultEventTypeService faultEventTypeService; + private final FaultEventTypeDao faultEventTypeDao; @Autowired public FaultTreeRepositoryService(@Qualifier("defaultValidator") Validator validator, @@ -53,7 +55,9 @@ public FaultTreeRepositoryService(@Qualifier("defaultValidator") Validator valid SecurityUtils securityUtils, FaultEventDao faultEventDao, OperationalDataFilterService operationalDataFilterService, - FailureModeDao failureModeDao) { + FailureModeDao failureModeDao, + FaultEventTypeService faultEventTypeService, + FaultEventTypeDao faultEventTypeDao) { super(validator, userDao, securityUtils); this.faultTreeDao = faultTreeDao; this.faultEventScenarioDao = faultEventScenarioDao; @@ -63,6 +67,8 @@ public FaultTreeRepositoryService(@Qualifier("defaultValidator") Validator valid this.faultEventDao = faultEventDao; this.operationalDataFilterService = operationalDataFilterService; this.failureModeDao = failureModeDao; + this.faultEventTypeService = faultEventTypeService; + this.faultEventTypeDao = faultEventTypeDao; } @Override @@ -86,7 +92,7 @@ public void createTree(FaultTree faultTree){ faultTree.getManifestingEvent().setSupertypes(Collections.singleton(evt)); } - faultEventDao.loadManagedSupertypesOrCreate(faultEvent, faultTree.getSystem(), faultTree.getUri()); + faultEventTypeService.loadManagedSupertypesOrCreate(faultEvent, faultTree.getSystem(), faultTree.getUri()); persist(faultTree); }