#178: uncheck sync when already present. fix issue that present heimat time for mapped project without work at that day is not syncable

Author: Death111

src/main/java/de/doubleslash/keeptime/controller/HeimatController.java

@@ -129,33 +129,36 @@ public List<Mapping> getTableRows(final LocalDate currentReportDate, final List<
             pr.appendToWorkNotes(currentWorkNote);
          }
          final String keeptimeNotes = pr.getNotes();
-         String canBeSynced;
+         String canBeSyncedMessage;
          if (!isMappedInHeimat) {
-            canBeSynced = "Not mapped to Heimat task.\nMap in settings dialog.";
+            canBeSyncedMessage = "Not mapped to Heimat task.\nMap in settings dialog.";
          } else if (heimatTasks.stream().noneMatch(ht -> ht.id() == optHeimatMapping.get().getExternalTaskId())) {
-            canBeSynced = "Heimat Task is not available (anymore).\nPlease check mappings in settings dialog.";
+            canBeSyncedMessage = "Heimat Task is not available (anymore).\nPlease check mappings in settings dialog.";
             isMappedInHeimat = false;
          } else {
             final ExternalProjectMapping externalProjectMapping = optHeimatMapping.get();
-            canBeSynced = "Sync to " + externalProjectMapping.getExternalTaskName() + "\n("
+            canBeSyncedMessage = "Sync to " + externalProjectMapping.getExternalTaskName() + "\n("
                   + externalProjectMapping.getExternalProjectName() + ")";
          }
 
          if (optionalExistingMapping.isPresent()) {
             final Mapping existingMapping = optionalExistingMapping.get();
             final ArrayList<Project> projects = new ArrayList<>(existingMapping.projects());
             projects.add(project);
+            final long keepTimeSeconds = existingMapping.keeptimeSeconds() + projectWorkSeconds;
+            final long heimatSeconds = existingMapping.heimatSeconds();
+            final boolean shouldBeSynced = isMappedInHeimat && differenceGreater15Minutes(heimatSeconds, keepTimeSeconds);
             final Mapping mapping = new Mapping(isMappedInHeimat ? optHeimatMapping.get().getExternalTaskId() : -1,
-                  isMappedInHeimat, canBeSynced, existingMapping.existingTimes(), projects,
-                  existingMapping.heimatNotes(), existingMapping.keeptimeNotes() + ". " + keeptimeNotes,
-                  existingMapping.heimatSeconds(), existingMapping.keeptimeSeconds() + projectWorkSeconds);
+                  isMappedInHeimat, shouldBeSynced, canBeSyncedMessage, existingMapping.existingTimes(), projects,
+                  existingMapping.heimatNotes(), existingMapping.keeptimeNotes() + ". " + keeptimeNotes, heimatSeconds, keepTimeSeconds);
             list.remove(existingMapping);
             list.add(mapping);
          } else {
+            final boolean shouldBeSynced = isMappedInHeimat && differenceGreater15Minutes(heimatTimeSeconds, projectWorkSeconds);
             final List<Project> projects = Collections.singletonList(project);
             final Mapping mapping = new Mapping(isMappedInHeimat ? optHeimatMapping.get().getExternalTaskId() : -1,
-                  isMappedInHeimat, canBeSynced, optionalAlreadyBookedTimes, projects, heimatNotes, keeptimeNotes,
-                  heimatTimeSeconds, projectWorkSeconds);
+                  isMappedInHeimat, shouldBeSynced, canBeSyncedMessage, optionalAlreadyBookedTimes, projects,
+                  heimatNotes, keeptimeNotes, heimatTimeSeconds, projectWorkSeconds);
             list.add(mapping);
          }
       }
@@ -175,7 +178,7 @@ public List<Mapping> getTableRows(final LocalDate currentReportDate, final List<
                                                   .filter(t -> t.id() == times.get(0).taskId())
                                                   .findAny()
                                                   .orElseThrow();
-         final Mapping mapping = new Mapping(id, false,
+         final Mapping mapping = new Mapping(id, true, false,
                "Not mapped in KeepTime\n\n" + heimatTask.name() + "\n" + heimatTask.taskHolderName(), times,
                new ArrayList<>(0), heimatNotes, "", heimatTimeSeconds, 0);
          list.add(mapping);
@@ -199,7 +202,7 @@ public List<Mapping> getTableRows(final LocalDate currentReportDate, final List<
          String heimatNotes = addHeimatNotes(times);
          long heimatTimeSeconds = addHeimatTimes(times);
 
-         final Mapping mapping2 = new Mapping(id, true,
+         final Mapping mapping2 = new Mapping(id, true, false,
                "Present in HEIMAT but not KeepTime\n\n" + externalProjectMapping.getExternalTaskName() + "\n"
                      + externalProjectMapping.getExternalProjectName(), times, mappedProjects.stream()
                                                                                              .filter(
@@ -214,6 +217,10 @@ public List<Mapping> getTableRows(final LocalDate currentReportDate, final List<
       return list;
    }
 
+   private static boolean differenceGreater15Minutes(final long heimatTimeSeconds, final long projectWorkSeconds) {
+      return heimatTimeSeconds == 0L || Math.abs(heimatTimeSeconds - projectWorkSeconds) > 15 * 60L;
+   }
+
    private static long addHeimatTimes(final List<HeimatTime> optionalAlreadyBookedTimes) {
       long heimatTimeSeconds;
       heimatTimeSeconds = optionalAlreadyBookedTimes.stream()
@@ -309,9 +316,9 @@ public void updateMappings(final List<ProjectMapping> newMappings) {
                                                                                         ExternalSystem.Heimat,
                                                                                         heimatTask.taskHolderName(),
                                                                                         heimatTask.id(),
-                                                                                        heimatTask.name(), getAsJson(
-                                                                                              heimatTask)
-                                                                                        , projectMapping.getProject());
+                                                                                        heimatTask.name(),
+                                                                                        getAsJson(heimatTask),
+                                                                                        projectMapping.getProject());
                                                                                })
                                                                                .filter(Objects::nonNull)
                                                                                .toList();
@@ -338,7 +345,7 @@ public void updateMappings(final List<ProjectMapping> newMappings) {
       externalProjectsMappingsRepository.deleteAll(mappingsToRemove);
    }
 
-   private String getAsJson(final HeimatTask heimatTask){
+   private String getAsJson(final HeimatTask heimatTask) {
       try {
          return objectMapper.writeValueAsString(heimatTask);
       } catch (JsonProcessingException e) {
@@ -394,9 +401,9 @@ public ExistingAndInvalidMappings getExistingProjectMappings(List<HeimatTask> ex
 
    public record UserMapping(Mapping mapping, boolean shouldSync, String userNotes, int userMinutes) {}
 
-   public record Mapping(long heimatTaskId, boolean canBeSynced, String syncMessage, List<HeimatTime> existingTimes,
-                         List<Project> projects, String heimatNotes, String keeptimeNotes, long heimatSeconds,
-                         long keeptimeSeconds) {}
+   public record Mapping(long heimatTaskId, boolean canBeSynced, boolean shouldBeSynced, String syncMessage,
+                         List<HeimatTime> existingTimes, List<Project> projects, String heimatNotes,
+                         String keeptimeNotes, long heimatSeconds, long keeptimeSeconds) {}
 
    public record HeimatErrors(UserMapping mapping, String errorMessage) {}
 

src/main/java/de/doubleslash/keeptime/view/ExternalProjectsSyncController.java

@@ -173,7 +173,7 @@ public void initForDate(LocalDate currentReportDate, List<Work> currentWorkItems
                          .bind(heimatTaskComboBox.getSelectionModel().selectedItemProperty().isNull());
       addHeimatTaskButton.setOnAction(ae -> {
          final HeimatTask task = heimatTaskComboBox.getValue();
-         items.add(new TableRow(new HeimatController.Mapping(task.id(), true,
+         items.add(new TableRow(new HeimatController.Mapping(task.id(), true, true,
                "Manually added\n\n" + task.name() + "\n(" + task.taskHolderName() + ")", List.of(), List.of(), "", "",
                0, 0), "", 0));
          heimatTaskComboBox.getSelectionModel().clearSelection();
@@ -427,6 +427,7 @@ protected List<HeimatController.HeimatErrors> call() {
             }
 
             PauseTransition delay = new PauseTransition(Duration.seconds(2));
+            // TODO maybe show countdown in UI with option to "Open day in HEIMAT"? could add 1 second again ;)
             delay.setOnFinished(event -> {
                showLoadingScreen(false);
                thisStage.close();
@@ -603,7 +604,7 @@ public static class TableRow {
 
       public TableRow(HeimatController.Mapping mapping, String userNotes, final long userSeconds) {
          this.mapping = mapping;
-         this.shouldSyncCheckBox = new SimpleBooleanProperty(mapping.canBeSynced());
+         this.shouldSyncCheckBox = new SimpleBooleanProperty(mapping.shouldBeSynced());
          this.syncStatus = new SimpleStringProperty(mapping.syncMessage());
 
          this.keeptimeNotes = new SimpleStringProperty(mapping.keeptimeNotes());

src/test/java/de/doubleslash/keeptime/controller/HeimatControllerTest.java

@@ -203,8 +203,10 @@ void shouldMarkNonSyncableWhenNotMapped() {
       final List<HeimatController.Mapping> tableRows = heimatController.getTableRows(now.toLocalDate(), workItems);
 
       // ASSERT
-      assertFalse(tableRows.get(0).canBeSynced());
-      assertThat(tableRows.get(0).heimatTaskId(), Matchers.is(-1L));
+      final HeimatController.Mapping mapping = tableRows.get(0);
+      assertFalse(mapping.canBeSynced());
+      assertFalse(mapping.shouldBeSynced());
+      assertThat(mapping.heimatTaskId(), Matchers.is(-1L));
    }
 
    @Test
@@ -218,8 +220,10 @@ void shouldMarkNonSyncableWhenHeimatTaskNoLongerExists() {
       final List<HeimatController.Mapping> tableRows = heimatController.getTableRows(now.toLocalDate(), workItems);
 
       // ASSERT
-      assertFalse(tableRows.get(0).canBeSynced());
-      assertThat(tableRows.get(0).syncMessage(), Matchers.containsString("is not available"));
+      final HeimatController.Mapping mapping = tableRows.get(0);
+      assertFalse(mapping.canBeSynced());
+      assertFalse(mapping.shouldBeSynced());
+      assertThat(mapping.syncMessage(), Matchers.containsString("is not available"));
    }
 
    @Test
@@ -234,6 +238,7 @@ void shouldBeSyncableWhenMapped() {
 
       // ASSERT
       assertTrue(mapping.canBeSynced());
+      assertTrue(mapping.shouldBeSynced());
       assertThat(mapping.keeptimeSeconds(), Matchers.is(13 * 60L));
       assertThat(mapping.keeptimeNotes(), Matchers.is("Notes 1"));
       assertThat(mapping.syncMessage(), Matchers.containsString(project1To1Mapping.getExternalTaskName()));
@@ -258,6 +263,7 @@ void shouldAddHeimatDetailsWhenAlreadyPresent() {
 
       // ASSERT
       assertAll(() -> assertTrue(mapping.canBeSynced()),
+            () -> assertTrue(mapping.shouldBeSynced()),
             () -> assertThat(mapping.keeptimeSeconds(), Matchers.is(13 * 60L)),
             () -> assertThat(mapping.keeptimeNotes(), Matchers.is("Notes 1")),
             () -> assertThat(mapping.projects(), Matchers.containsInAnyOrder(workProject1)),
@@ -267,6 +273,32 @@ void shouldAddHeimatDetailsWhenAlreadyPresent() {
             //
       );
    }
+   @Test
+   void shouldDisableShouldBeSyncedWhenAlreadyPresentInHeimat() {
+      // ARRANGE
+      final Work work1 = new Work(now.minusMinutes(55), now, workProject1, "Notes 1");
+      workItems.add(work1);
+      externalMappings.add(project1To1Mapping);
+      final HeimatTime existingTime1 = new HeimatTime(project1To1Mapping.getExternalTaskId(), now.toLocalDate(), null,
+            null, 60, "Existing note 1", 12);
+      when(mockedHeimatAPI.getMyTimes(now.toLocalDate())).thenReturn(Arrays.asList(existingTime1));
+
+      // ACT
+      final List<HeimatController.Mapping> tableRows = heimatController.getTableRows(now.toLocalDate(), workItems);
+      final HeimatController.Mapping mapping = tableRows.get(0);
+
+      // ASSERT
+      assertAll(() -> assertTrue(mapping.canBeSynced()),
+            () -> assertFalse(mapping.shouldBeSynced()),
+            () -> assertThat(mapping.keeptimeSeconds(), Matchers.is(55 * 60L)),
+            () -> assertThat(mapping.keeptimeNotes(), Matchers.is("Notes 1")),
+            () -> assertThat(mapping.projects(), Matchers.containsInAnyOrder(workProject1)),
+            () -> assertThat(mapping.heimatNotes(), Matchers.is("Existing note 1")),
+            () -> assertThat(mapping.heimatSeconds(), Matchers.is((60) * 60L)),
+            () -> assertThat(mapping.existingTimes(), Matchers.containsInAnyOrder(existingTime1))
+            //
+      );
+   }
 
    @Test
    void shouldCombineAllWorksAndProjectsWhenMultipleProjectsAreMappedToSame() {
@@ -284,13 +316,12 @@ void shouldCombineAllWorksAndProjectsWhenMultipleProjectsAreMappedToSame() {
 
       // ASSERT
       assertAll(() -> assertTrue(mapping.canBeSynced()),
+            () -> assertTrue(mapping.shouldBeSynced()),
             () -> assertThat(mapping.keeptimeSeconds(), Matchers.is(2 * 13 * 60L)),
             () -> assertThat(mapping.keeptimeNotes(), Matchers.is("Notes 1. Notes 2")),
             () -> assertThat(mapping.projects(), Matchers.containsInAnyOrder(workProject1, workProject2)));
    }
 
-   // shouldDisableShouldBeSyncedWhenAlreadyPresentInHeimat (nice 2 have)
-
    @Test
    void shouldShowHeimatTimeWhenProjectIsNotMappedInKeeptime() {
       // ARRANGE
@@ -307,7 +338,8 @@ void shouldShowHeimatTimeWhenProjectIsNotMappedInKeeptime() {
       final HeimatController.Mapping mapping = tableRows.get(0);
 
       // ASSERT
-      assertAll(() -> assertFalse(mapping.canBeSynced()),
+      assertAll(() -> assertTrue(mapping.canBeSynced()),
+            () -> assertFalse(mapping.shouldBeSynced()),
             () -> assertThat(mapping.syncMessage(), Matchers.containsString("Not mapped in KeepTime")),
             () -> assertThat(mapping.syncMessage(), Matchers.containsString(project1To1Mapping.getExternalTaskName())),
             () -> assertThat(mapping.keeptimeSeconds(), Matchers.is(0L)),
@@ -338,6 +370,8 @@ void shouldShowHeimatTimeWhenProjectIsMappedInKeeptimeButNoWorkAtThatDay() {
 
       // ASSERT
       assertAll(() -> assertThat(tableRows.size(), Matchers.is(1)), () -> assertTrue(mapping.canBeSynced()),
+            () -> assertTrue(mapping.canBeSynced()),
+            () -> assertFalse(mapping.shouldBeSynced()),
             () -> assertThat(mapping.syncMessage(), Matchers.containsString("Present in HEIMAT but not KeepTime")),
             () -> assertThat(mapping.syncMessage(), Matchers.containsString(project1To1Mapping.getExternalTaskName())),
             () -> assertThat(mapping.keeptimeSeconds(), Matchers.is(0L)),