private void deletePreviousEventsHavingSameVersion(DbSession session, String version, Component component) { for (EventDto dto : dbClient.eventDao().selectByComponentUuid(session, component.getUuid())) { if (Objects.equals(dto.getCategory(), EventDto.CATEGORY_VERSION) && Objects.equals(dto.getName(), version)) { dbClient.eventDao().delete(session, dto.getId()); } } }
private void processEvents(DbSession session, Component component, Long analysisDate) { Function<Event, EventDto> eventToEventDto = event -> newBaseEvent(component, analysisDate) .setName(event.getName()) .setCategory(convertCategory(event.getCategory())) .setDescription(event.getDescription()) .setData(event.getData()); // FIXME bulk insert for (EventDto batchEventDto : StreamSupport.stream(eventRepository.getEvents(component).spliterator(), false).map(eventToEventDto).collect(Collectors.toList())) { dbClient.eventDao().insert(session, batchEventDto); } }
private void checkExistingDbEvents(DbSession dbSession, CreateEventRequest request, SnapshotDto analysis) { List<EventDto> dbEvents = dbClient.eventDao().selectByAnalysisUuid(dbSession, analysis.getUuid()); Predicate<EventDto> similarEventExisting = filterSimilarEvents(request); dbEvents.stream() .filter(similarEventExisting) .findAny() .ifPresent(throwException(request)); }
@Test public void select_by_component_uuid() { dbTester.prepareDbUnit(getClass(), "shared.xml"); List<EventDto> dtos = underTest.selectByComponentUuid(dbTester.getSession(), "ABCD"); assertThat(dtos).hasSize(3); dtos = underTest.selectByComponentUuid(dbTester.getSession(), "BCDE"); assertThat(dtos).hasSize(1); EventDto dto = dtos.get(0); assertThat(dto.getId()).isEqualTo(4L); assertThat(dto.getUuid()).isEqualTo("E4"); assertThat(dto.getAnalysisUuid()).isEqualTo("uuid_1"); assertThat(dto.getComponentUuid()).isEqualTo("BCDE"); assertThat(dto.getName()).isEqualTo("1.0"); assertThat(dto.getCategory()).isEqualTo("Version"); assertThat(dto.getDescription()).isEqualTo("Version 1.0"); assertThat(dto.getData()).isEqualTo("some data"); assertThat(dto.getDate()).isEqualTo(1413407091086L); assertThat(dto.getCreatedAt()).isEqualTo(1225630680000L); }
private EventDto getEvent(DbSession dbSession, String event) { return dbClient.eventDao().selectByUuid(dbSession, event) .orElseThrow(() -> new NotFoundException(format("Event '%s' not found", event))); }
@Test public void update_name_and_description() { SnapshotDto analysis = dbTester.components().insertProjectAndSnapshot(ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert())); dbTester.events().insertEvent(newEvent(analysis).setUuid("E1")); underTest.update(dbSession, "E1", "New Name", "New Description"); EventDto result = dbClient.eventDao().selectByUuid(dbSession, "E1").get(); assertThat(result.getName()).isEqualTo("New Name"); assertThat(result.getDescription()).isEqualTo("New Description"); }
private void deleteEvent(DbSession dbSession, EventDto dbEvent) { if (VERSION.getLabel().equals(dbEvent.getCategory())) { SnapshotDto analysis = dbClient.snapshotDao().selectByUuid(dbSession, dbEvent.getAnalysisUuid()) .orElseThrow(() -> new IllegalStateException(format("Analysis '%s' not found", dbEvent.getAnalysisUuid()))); checkArgument(!analysis.getLast(), "Cannot delete the version event of last analysis"); analysis.setVersion(null); dbClient.snapshotDao().update(dbSession, analysis); } dbClient.eventDao().delete(dbSession, dbEvent.getUuid()); dbSession.commit(); }
public EventDto insert(DbSession session, EventDto dto) { mapper(session).insert(dto); return dto; }
private void addEvents(SearchData.Builder data) { List<String> analyses = data.getAnalyses().stream().map(SnapshotDto::getUuid).collect(toList()); data.setEvents(dbClient.eventDao().selectByAnalysisUuids(data.getDbSession(), analyses)); data.setComponentChanges(dbClient.eventComponentChangeDao().selectByAnalysisUuids(data.getDbSession(), analyses)); }
private Consumer<EventDto> updateInDb(DbSession dbSession) { return event -> { dbClient.eventDao().update(dbSession, event.getUuid(), event.getName(), event.getDescription()); if (VERSION.getLabel().equals(event.getCategory())) { SnapshotDto analysis = getAnalysis(dbSession, event); analysis.setVersion(event.getName()); dbClient.snapshotDao().update(dbSession, analysis); } dbSession.commit(); }; }
@Test public void return_different_categories() { dbTester.prepareDbUnit(getClass(), "shared.xml"); List<EventDto> dtos = underTest.selectByComponentUuid(dbTester.getSession(), "ABCD"); assertThat(dtos).extracting("category").containsOnly(EventDto.CATEGORY_ALERT, EventDto.CATEGORY_PROFILE, EventDto.CATEGORY_VERSION); }
private EventDto getDbEvent(DbSession dbSession, UpdateEventRequest request) { checkArgument(isNotBlank(request.getName()), "A non empty name is required"); return dbClient.eventDao().selectByUuid(dbSession, request.getEvent()) .orElseThrow(() -> new NotFoundException(format("Event '%s' not found", request.getEvent()))); }
@Test public void delete_by_id() { dbTester.prepareDbUnit(getClass(), "delete.xml"); underTest.delete(dbTester.getSession(), 1L); dbTester.getSession().commit(); assertThat(dbTester.countRowsOfTable("events")).isEqualTo(0); }
public Optional<EventDto> selectByUuid(DbSession dbSession, String uuid) { return Optional.ofNullable(mapper(dbSession).selectByUuid(uuid)); }
@Test public void select_by_analysis_uuids() { ComponentDto project = dbTester.components().insertPrivateProject(); SnapshotDto a1 = dbTester.components().insertSnapshot(newAnalysis(project)); SnapshotDto a2 = dbTester.components().insertSnapshot(newAnalysis(project)); SnapshotDto a42 = dbTester.components().insertSnapshot(newAnalysis(project)); dbTester.events().insertEvent(newEvent(newAnalysis(project))); dbTester.events().insertEvent(newEvent(a1).setUuid("A11")); dbTester.events().insertEvent(newEvent(a1).setUuid("A12")); dbTester.events().insertEvent(newEvent(a1).setUuid("A13")); dbTester.events().insertEvent(newEvent(a2).setUuid("A21")); dbTester.events().insertEvent(newEvent(a2).setUuid("A22")); dbTester.events().insertEvent(newEvent(a2).setUuid("A23")); dbTester.events().insertEvent(newEvent(a42).setUuid("AO1")); dbTester.events().insertEvent(newEvent(a42).setUuid("AO2")); dbTester.events().insertEvent(newEvent(a42).setUuid("AO3")); List<EventDto> result = underTest.selectByAnalysisUuids(dbSession, newArrayList(a1.getUuid(), a2.getUuid())); assertThat(result).hasSize(6); assertThat(result).extracting(EventDto::getUuid).containsOnly("A11", "A12", "A13", "A21", "A22", "A23"); }
private Consumer<EventDto> updateInDb(DbSession dbSession) { return event -> { dbClient.eventDao().update(dbSession, event.getUuid(), event.getName(), event.getDescription()); if (VERSION.getLabel().equals(event.getCategory())) { SnapshotDto analysis = getAnalysis(dbSession, event); analysis.setVersion(event.getName()); dbClient.snapshotDao().update(dbSession, analysis); } dbSession.commit(); }; }
private void deletePreviousEventsHavingSameVersion(DbSession session, String version, Component component) { for (EventDto dto : dbClient.eventDao().selectByComponentUuid(session, component.getUuid())) { if (Objects.equals(dto.getCategory(), EventDto.CATEGORY_VERSION) && Objects.equals(dto.getName(), version)) { dbClient.eventDao().delete(session, dto.getId()); } } }
@Test public void persist_profile_events_on_root() { when(system2.now()).thenReturn(NOW); treeRootHolder.setRoot(ROOT); Event profile = Event.createProfile("foo", null, "bar"); when(eventRepository.getEvents(ROOT)).thenReturn(ImmutableList.of(profile)); underTest.execute(new TestComputationStepContext()); assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "events")).isEqualTo(2); List<EventDto> eventDtos = dbTester.getDbClient().eventDao().selectByComponentUuid(dbTester.getSession(), ROOT.getUuid()); assertThat(eventDtos) .extracting(EventDto::getCategory) .containsOnly(CATEGORY_PROFILE, CATEGORY_VERSION); EventDto eventDto = eventDtos.stream().filter(t -> CATEGORY_PROFILE.equals(t.getCategory())).findAny().get(); assertThat(eventDto.getComponentUuid()).isEqualTo(ROOT.getUuid()); assertThat(eventDto.getName()).isEqualTo(profile.getName()); assertThat(eventDto.getDescription()).isEqualTo(profile.getDescription()); assertThat(eventDto.getCategory()).isEqualTo(EventDto.CATEGORY_PROFILE); assertThat(eventDto.getData()).isNull(); assertThat(eventDto.getDate()).isEqualTo(analysisMetadataHolder.getAnalysisDate()); assertThat(eventDto.getCreatedAt()).isEqualTo(NOW); }
public EventDto insertEvent(EventDto event) { dbClient.eventDao().insert(dbSession, event); db.commit(); return event; }
@Test public void update_name_in_db() { SnapshotDto analysis = createAnalysisAndLogInAsProjectAdministrator("5.6"); EventDto originalEvent = db.events().insertEvent(newEvent(analysis).setUuid("E1").setName("Original Name")); call("E1", "name"); EventDto newEvent = dbClient.eventDao().selectByUuid(dbSession, "E1").get(); assertThat(newEvent.getName()).isEqualTo("name"); assertThat(newEvent.getDescription()).isNull(); assertThat(newEvent.getCategory()).isEqualTo(originalEvent.getCategory()); assertThat(newEvent.getDate()).isEqualTo(originalEvent.getDate()); assertThat(newEvent.getCreatedAt()).isEqualTo(originalEvent.getCreatedAt()); }