From 608fce6a128c5d6cbd3d9fa9f14c91e09b1cbe5d Mon Sep 17 00:00:00 2001 From: vaibhav45sktech <232676907+vaibhav45sktech@users.noreply.github.com> Date: Mon, 7 Sep 2026 16:12:22 +0530 Subject: [PATCH 1/2] feat(badges): config, freezes and earned-log endpoints for SAKHI badges GET /badges/{config,freezes,earned} and POST /badges/earned; the ASHA is taken from the JWT, re-uploads are idempotent, defaults seeded on boot. --- .../iemr/flw/controller/BadgeController.java | 108 ++++++++++++++++++ .../com/iemr/flw/domain/iemr/BadgeConfig.java | 28 +++++ .../com/iemr/flw/domain/iemr/BadgeEarned.java | 45 ++++++++ .../flw/domain/iemr/BadgeStreakFreeze.java | 37 ++++++ .../com/iemr/flw/dto/iemr/BadgeEarnedDTO.java | 15 +++ .../iemr/flw/dto/iemr/BadgeEarnedPushDTO.java | 15 +++ .../iemr/flw/repo/iemr/BadgeConfigRepo.java | 9 ++ .../iemr/flw/repo/iemr/BadgeEarnedRepo.java | 14 +++ .../flw/repo/iemr/BadgeStreakFreezeRepo.java | 13 +++ .../iemr/flw/seeder/BadgeConfigSeeder.java | 49 ++++++++ .../com/iemr/flw/service/BadgeService.java | 74 ++++++++++++ .../flw/controller/BadgeControllerTest.java | 89 +++++++++++++++ .../iemr/flw/service/BadgeServiceTest.java | 55 +++++++++ 13 files changed, 551 insertions(+) create mode 100644 src/main/java/com/iemr/flw/controller/BadgeController.java create mode 100644 src/main/java/com/iemr/flw/domain/iemr/BadgeConfig.java create mode 100644 src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java create mode 100644 src/main/java/com/iemr/flw/domain/iemr/BadgeStreakFreeze.java create mode 100644 src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java create mode 100644 src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedPushDTO.java create mode 100644 src/main/java/com/iemr/flw/repo/iemr/BadgeConfigRepo.java create mode 100644 src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java create mode 100644 src/main/java/com/iemr/flw/repo/iemr/BadgeStreakFreezeRepo.java create mode 100644 src/main/java/com/iemr/flw/seeder/BadgeConfigSeeder.java create mode 100644 src/main/java/com/iemr/flw/service/BadgeService.java create mode 100644 src/test/java/com/iemr/flw/controller/BadgeControllerTest.java create mode 100644 src/test/java/com/iemr/flw/service/BadgeServiceTest.java diff --git a/src/main/java/com/iemr/flw/controller/BadgeController.java b/src/main/java/com/iemr/flw/controller/BadgeController.java new file mode 100644 index 000000000..aa5fb4855 --- /dev/null +++ b/src/main/java/com/iemr/flw/controller/BadgeController.java @@ -0,0 +1,108 @@ +package com.iemr.flw.controller; + +import com.iemr.flw.dto.iemr.BadgeEarnedPushDTO; +import com.iemr.flw.service.BadgeService; +import com.iemr.flw.utils.JwtUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.HashMap; +import java.util.Map; + +/** + * Badges API consumed by the SAKHI app's BadgeSyncWorker: + * GET /badges/config -> { "config": { key: value } } + * GET /badges/freezes -> { "freezes": [ { badgeId, startDate, endDate } ] } + * GET /badges/earned -> { "earned": [ { badgeId, level, earnedAt } ] } + * POST /badges/earned <- { userId, badges: [ { badgeId, level, earnedAt } ] } + * The ASHA is always identified from the JWT, never from the payload. + */ +@RestController +@RequestMapping(value = "/badges", produces = "application/json") +public class BadgeController { + + private final Logger logger = LoggerFactory.getLogger(this.getClass().getSimpleName()); + private final BadgeService badgeService; + private final JwtUtil jwtUtil; + + public BadgeController(BadgeService badgeService, JwtUtil jwtUtil) { + this.badgeService = badgeService; + this.jwtUtil = jwtUtil; + } + + @GetMapping("/config") + public ResponseEntity> getConfig() { + Map response = ok(); + try { + response.put("config", badgeService.getConfig()); + return ResponseEntity.ok(response); + } catch (Exception e) { + return error(e); + } + } + + @GetMapping("/freezes") + public ResponseEntity> getFreezes( + @RequestHeader(value = "JwtToken") String jwtToken) { + Map response = ok(); + try { + Integer userId = jwtUtil.extractUserId(jwtToken); + response.put("freezes", badgeService.getFreezes(userId)); + return ResponseEntity.ok(response); + } catch (Exception e) { + return error(e); + } + } + + @GetMapping("/earned") + public ResponseEntity> getEarned( + @RequestHeader(value = "JwtToken") String jwtToken) { + Map response = ok(); + try { + Integer userId = jwtUtil.extractUserId(jwtToken); + response.put("earned", badgeService.getEarned(userId)); + return ResponseEntity.ok(response); + } catch (Exception e) { + return error(e); + } + } + + @PostMapping(value = "/earned", consumes = "application/json") + public ResponseEntity> postEarned( + @RequestHeader(value = "JwtToken") String jwtToken, + @RequestBody BadgeEarnedPushDTO body) { + Map response = ok(); + try { + Integer userId = jwtUtil.extractUserId(jwtToken); + int inserted = badgeService.saveEarned(userId, body == null ? null : body.getBadges()); + response.put("inserted", inserted); + return ResponseEntity.ok(response); + } catch (Exception e) { + return error(e); + } + } + + private Map ok() { + Map response = new HashMap<>(); + response.put("statusCode", 200); + response.put("status", "Success"); + return response; + } + + private ResponseEntity> error(Exception e) { + logger.error("Badges API error:", e); + Map response = new HashMap<>(); + response.put("statusCode", 500); + response.put("status", "Error"); + response.put("errorMessage", e.getMessage()); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response); + } +} diff --git a/src/main/java/com/iemr/flw/domain/iemr/BadgeConfig.java b/src/main/java/com/iemr/flw/domain/iemr/BadgeConfig.java new file mode 100644 index 000000000..909871114 --- /dev/null +++ b/src/main/java/com/iemr/flw/domain/iemr/BadgeConfig.java @@ -0,0 +1,28 @@ +package com.iemr.flw.domain.iemr; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Badge tuning as key/value rows (Badge LLD §5.2). Overrides the app's + * compiled defaults without a release, e.g. "milestones.steady_syncer" -> "2,4,6,8". + */ +@Entity +@Data +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "badge_config", schema = "db_iemr") +public class BadgeConfig { + + @Id + @Column(name = "config_key", length = 100) + private String key; + + @Column(name = "config_value", length = 500, nullable = false) + private String value; +} diff --git a/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java b/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java new file mode 100644 index 000000000..b73864257 --- /dev/null +++ b/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java @@ -0,0 +1,45 @@ +package com.iemr.flw.domain.iemr; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import jakarta.persistence.UniqueConstraint; +import lombok.Data; + +/** + * Append-only badge award log (Badge LLD §4.1, "once earned, never revoked"). + * The unique key mirrors the device's local constraint so re-uploads after a + * reinstall or a retried sync are idempotent. + */ +@Entity +@Data +@Table(name = "badge_earned", schema = "db_iemr", + uniqueConstraints = @UniqueConstraint( + name = "uk_badge_earned_user_badge_level", + columnNames = {"user_id", "badge_id", "level"})) +public class BadgeEarned { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + @Column(name = "user_id", nullable = false) + private Integer userId; + + @Column(name = "badge_id", length = 50, nullable = false) + private String badgeId; + + @Column(name = "level", nullable = false) + private Integer level; + + /** Epoch millis when the device awarded it. */ + @Column(name = "earned_at", nullable = false) + private Long earnedAt; + + /** Epoch millis when the server first received it. */ + @Column(name = "received_at", nullable = false) + private Long receivedAt; +} diff --git a/src/main/java/com/iemr/flw/domain/iemr/BadgeStreakFreeze.java b/src/main/java/com/iemr/flw/domain/iemr/BadgeStreakFreeze.java new file mode 100644 index 000000000..afc7a9870 --- /dev/null +++ b/src/main/java/com/iemr/flw/domain/iemr/BadgeStreakFreeze.java @@ -0,0 +1,37 @@ +package com.iemr.flw.domain.iemr; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import lombok.Data; + +/** + * Streak-freeze window (Badge LLD §3.3): illness / alternate duty. A null userId + * applies to every ASHA; a null or empty badgeId applies to every streak badge. + */ +@Entity +@Data +@Table(name = "badge_streak_freeze", schema = "db_iemr") +public class BadgeStreakFreeze { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + @Column(name = "user_id") + private Integer userId; + + @Column(name = "badge_id", length = 50) + private String badgeId; + + /** Epoch millis, inclusive. */ + @Column(name = "start_date", nullable = false) + private Long startDate; + + /** Epoch millis, inclusive. */ + @Column(name = "end_date", nullable = false) + private Long endDate; +} diff --git a/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java b/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java new file mode 100644 index 000000000..9ce8d6a79 --- /dev/null +++ b/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java @@ -0,0 +1,15 @@ +package com.iemr.flw.dto.iemr; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** Wire shape shared with the app's BadgeEarnedDTO (Moshi). */ +@Data +@NoArgsConstructor +@AllArgsConstructor +public class BadgeEarnedDTO { + private String badgeId; + private Integer level; + private Long earnedAt; +} diff --git a/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedPushDTO.java b/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedPushDTO.java new file mode 100644 index 000000000..dddca01c1 --- /dev/null +++ b/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedPushDTO.java @@ -0,0 +1,15 @@ +package com.iemr.flw.dto.iemr; + +import lombok.Data; + +import java.util.List; + +/** + * POST /badges/earned body. The userId field is accepted for wire compatibility + * but never trusted: the owner is always taken from the JWT. + */ +@Data +public class BadgeEarnedPushDTO { + private Integer userId; + private List badges; +} diff --git a/src/main/java/com/iemr/flw/repo/iemr/BadgeConfigRepo.java b/src/main/java/com/iemr/flw/repo/iemr/BadgeConfigRepo.java new file mode 100644 index 000000000..0341fa8f1 --- /dev/null +++ b/src/main/java/com/iemr/flw/repo/iemr/BadgeConfigRepo.java @@ -0,0 +1,9 @@ +package com.iemr.flw.repo.iemr; + +import com.iemr.flw.domain.iemr.BadgeConfig; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface BadgeConfigRepo extends JpaRepository { +} diff --git a/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java b/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java new file mode 100644 index 000000000..219571a55 --- /dev/null +++ b/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java @@ -0,0 +1,14 @@ +package com.iemr.flw.repo.iemr; + +import com.iemr.flw.domain.iemr.BadgeEarned; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface BadgeEarnedRepo extends JpaRepository { + List findByUserIdOrderByEarnedAtAsc(Integer userId); + + boolean existsByUserIdAndBadgeIdAndLevel(Integer userId, String badgeId, Integer level); +} diff --git a/src/main/java/com/iemr/flw/repo/iemr/BadgeStreakFreezeRepo.java b/src/main/java/com/iemr/flw/repo/iemr/BadgeStreakFreezeRepo.java new file mode 100644 index 000000000..adc063d94 --- /dev/null +++ b/src/main/java/com/iemr/flw/repo/iemr/BadgeStreakFreezeRepo.java @@ -0,0 +1,13 @@ +package com.iemr.flw.repo.iemr; + +import com.iemr.flw.domain.iemr.BadgeStreakFreeze; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface BadgeStreakFreezeRepo extends JpaRepository { + /** Global windows (user_id IS NULL) plus this ASHA's own. */ + List findByUserIdIsNullOrUserId(Integer userId); +} diff --git a/src/main/java/com/iemr/flw/seeder/BadgeConfigSeeder.java b/src/main/java/com/iemr/flw/seeder/BadgeConfigSeeder.java new file mode 100644 index 000000000..1c83833a5 --- /dev/null +++ b/src/main/java/com/iemr/flw/seeder/BadgeConfigSeeder.java @@ -0,0 +1,49 @@ +package com.iemr.flw.seeder; + +import com.iemr.flw.domain.iemr.BadgeConfig; +import com.iemr.flw.repo.iemr.BadgeConfigRepo; +import jakarta.annotation.PostConstruct; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import java.util.List; + +/** + * Seeds the default badge tuning once (table empty). Values mirror the app's + * compiled defaults so a fresh server changes nothing until someone edits a row. + */ +@Component +public class BadgeConfigSeeder { + + private static final Logger log = LoggerFactory.getLogger(BadgeConfigSeeder.class); + + private final BadgeConfigRepo repo; + + public BadgeConfigSeeder(BadgeConfigRepo repo) { + this.repo = repo; + } + + @PostConstruct + public void seed() { + try { + if (repo.count() > 0) return; + repo.saveAll(List.of( + new BadgeConfig("feature_enabled", "true"), + new BadgeConfig("copy_version", "1"), + new BadgeConfig("milestones.steady_syncer", "2,4,6,8"), + new BadgeConfig("grace.steady_syncer", "1"), + new BadgeConfig("milestones.timely_reporter", "1,3,6,12"), + new BadgeConfig("milestones.complete_worker", "3"), + new BadgeConfig("milestones.community_voice", "2"), + new BadgeConfig("milestones.maternal_journey", "1,5,15,30"), + new BadgeConfig("milestones.child_fully_protected", "3,10,25,60"), + new BadgeConfig("milestones.digital_identity", "10,25,75,150"), + new BadgeConfig("enabled.critical_referral", "false") + )); + log.info("Badge config defaults seeded"); + } catch (Exception e) { + log.warn("Badge config seeding skipped: {}", e.getMessage()); + } + } +} diff --git a/src/main/java/com/iemr/flw/service/BadgeService.java b/src/main/java/com/iemr/flw/service/BadgeService.java new file mode 100644 index 000000000..074ad878e --- /dev/null +++ b/src/main/java/com/iemr/flw/service/BadgeService.java @@ -0,0 +1,74 @@ +package com.iemr.flw.service; + +import com.iemr.flw.domain.iemr.BadgeConfig; +import com.iemr.flw.domain.iemr.BadgeEarned; +import com.iemr.flw.domain.iemr.BadgeStreakFreeze; +import com.iemr.flw.dto.iemr.BadgeEarnedDTO; +import com.iemr.flw.repo.iemr.BadgeConfigRepo; +import com.iemr.flw.repo.iemr.BadgeEarnedRepo; +import com.iemr.flw.repo.iemr.BadgeStreakFreezeRepo; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** + * Badges backend (Badge LLD §4). The device owns evaluation; the server only + * distributes tuning + freeze windows and keeps the durable award log so a + * reinstall restores progress. + */ +@Service +public class BadgeService { + + private final BadgeConfigRepo configRepo; + private final BadgeStreakFreezeRepo freezeRepo; + private final BadgeEarnedRepo earnedRepo; + + public BadgeService(BadgeConfigRepo configRepo, BadgeStreakFreezeRepo freezeRepo, + BadgeEarnedRepo earnedRepo) { + this.configRepo = configRepo; + this.freezeRepo = freezeRepo; + this.earnedRepo = earnedRepo; + } + + public Map getConfig() { + Map out = new LinkedHashMap<>(); + for (BadgeConfig row : configRepo.findAll()) { + out.put(row.getKey(), row.getValue()); + } + return out; + } + + public List getFreezes(Integer userId) { + return freezeRepo.findByUserIdIsNullOrUserId(userId); + } + + public List getEarned(Integer userId) { + return earnedRepo.findByUserIdOrderByEarnedAtAsc(userId).stream() + .map(e -> new BadgeEarnedDTO(e.getBadgeId(), e.getLevel(), e.getEarnedAt())) + .toList(); + } + + /** Idempotent: rows already known for (user, badge, level) are skipped. Returns rows inserted. */ + @Transactional + public int saveEarned(Integer userId, List badges) { + if (badges == null || badges.isEmpty()) return 0; + long now = System.currentTimeMillis(); + int inserted = 0; + for (BadgeEarnedDTO dto : badges) { + if (dto == null || dto.getBadgeId() == null || dto.getLevel() == null) continue; + if (earnedRepo.existsByUserIdAndBadgeIdAndLevel(userId, dto.getBadgeId(), dto.getLevel())) continue; + BadgeEarned row = new BadgeEarned(); + row.setUserId(userId); + row.setBadgeId(dto.getBadgeId()); + row.setLevel(dto.getLevel()); + row.setEarnedAt(dto.getEarnedAt() != null ? dto.getEarnedAt() : now); + row.setReceivedAt(now); + earnedRepo.save(row); + inserted++; + } + return inserted; + } +} diff --git a/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java b/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java new file mode 100644 index 000000000..bb6069936 --- /dev/null +++ b/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java @@ -0,0 +1,89 @@ +package com.iemr.flw.controller; + +import com.iemr.flw.dto.iemr.BadgeEarnedDTO; +import com.iemr.flw.service.BadgeService; +import com.iemr.flw.utils.JwtUtil; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.http.MediaType; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +class BadgeControllerTest { + + private MockMvc mockMvc; + + @Mock + private BadgeService badgeService; + + @Mock + private JwtUtil jwtUtil; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + mockMvc = MockMvcBuilders.standaloneSetup(new BadgeController(badgeService, jwtUtil)).build(); + } + + @Test + void config_returnsKeyValueMapUnderConfig() throws Exception { + when(badgeService.getConfig()).thenReturn(Map.of("milestones.steady_syncer", "2,4,6,8")); + + mockMvc.perform(get("/badges/config")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.config['milestones.steady_syncer']").value("2,4,6,8")); + } + + @Test + void earned_usesUserIdFromJwtNotFromBody() throws Exception { + when(jwtUtil.extractUserId("tok")).thenReturn(960); + when(badgeService.saveEarned(eq(960), any())).thenReturn(1); + + mockMvc.perform(post("/badges/earned") + .header("JwtToken", "tok") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"userId\":12345,\"badges\":[{\"badgeId\":\"steady_syncer\",\"level\":2,\"earnedAt\":1}]}")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.inserted").value(1)); + + ArgumentCaptor> captor = ArgumentCaptor.forClass(List.class); + verify(badgeService).saveEarned(eq(960), captor.capture()); + assertEquals("steady_syncer", captor.getValue().get(0).getBadgeId()); + } + + @Test + void getEarned_returnsListUnderEarned() throws Exception { + when(jwtUtil.extractUserId("tok")).thenReturn(960); + when(badgeService.getEarned(960)).thenReturn(List.of(new BadgeEarnedDTO("timely_reporter", 1, 5L))); + + mockMvc.perform(get("/badges/earned").header("JwtToken", "tok")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.earned[0].badgeId").value("timely_reporter")) + .andExpect(jsonPath("$.earned[0].level").value(1)); + } + + @Test + void invalidJwt_returns500WithErrorShape() throws Exception { + when(jwtUtil.extractUserId("bad")).thenThrow(new RuntimeException("Invalid JWT token.")); + + mockMvc.perform(get("/badges/earned").header("JwtToken", "bad")) + .andExpect(status().isInternalServerError()) + .andExpect(jsonPath("$.status").value("Error")); + } +} diff --git a/src/test/java/com/iemr/flw/service/BadgeServiceTest.java b/src/test/java/com/iemr/flw/service/BadgeServiceTest.java new file mode 100644 index 000000000..b1e7ac384 --- /dev/null +++ b/src/test/java/com/iemr/flw/service/BadgeServiceTest.java @@ -0,0 +1,55 @@ +package com.iemr.flw.service; + +import com.iemr.flw.domain.iemr.BadgeEarned; +import com.iemr.flw.dto.iemr.BadgeEarnedDTO; +import com.iemr.flw.repo.iemr.BadgeConfigRepo; +import com.iemr.flw.repo.iemr.BadgeEarnedRepo; +import com.iemr.flw.repo.iemr.BadgeStreakFreezeRepo; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class BadgeServiceTest { + + @Mock private BadgeConfigRepo configRepo; + @Mock private BadgeStreakFreezeRepo freezeRepo; + @Mock private BadgeEarnedRepo earnedRepo; + + private BadgeService service; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + service = new BadgeService(configRepo, freezeRepo, earnedRepo); + } + + @Test + void saveEarned_skipsRowsAlreadyKnown_idempotentReupload() { + when(earnedRepo.existsByUserIdAndBadgeIdAndLevel(960, "steady_syncer", 1)).thenReturn(true); + when(earnedRepo.existsByUserIdAndBadgeIdAndLevel(960, "steady_syncer", 2)).thenReturn(false); + + int inserted = service.saveEarned(960, List.of( + new BadgeEarnedDTO("steady_syncer", 1, 10L), + new BadgeEarnedDTO("steady_syncer", 2, 20L))); + + assertEquals(1, inserted); + verify(earnedRepo, times(1)).save(any(BadgeEarned.class)); + } + + @Test + void saveEarned_ignoresMalformedEntriesAndEmptyLists() { + assertEquals(0, service.saveEarned(960, null)); + assertEquals(0, service.saveEarned(960, List.of(new BadgeEarnedDTO(null, null, null)))); + verify(earnedRepo, never()).save(any()); + } +} From 37f1c148487c5fbd220126f1cb64dd5f0b12aab6 Mon Sep 17 00:00:00 2001 From: vaibhav45sktech <232676907+vaibhav45sktech@users.noreply.github.com> Date: Sat, 12 Sep 2026 00:52:49 +0530 Subject: [PATCH 2/2] feat(badges): carry a stable award key on the earned log MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit (user_id, badge_id, level) is not unique for every badge. Quarterly badges are re-earned each quarter at the same level, and per-case badges once per beneficiary, so two genuine awards collided on the old constraint: the second was silently skipped as a duplicate on upload and could not be told apart on restore. badge_earned gains award_key and the unique key becomes (user_id, badge_id, level, award_key). The key is a quarter key such as "2026-Q3", or an opaque digest for per-case awards, and empty for streak and cumulative badges, which are earned once per level. It is never a beneficiary identifier. The device hashes those before they are sent, so this column can separate two awards without the server learning who either was about (Badge LLD §4). A missing key is stored as empty rather than rejected. That is what a streak or cumulative badge sends, and also what a client predating the field sends for everything, so such a client keeps behaving exactly as it did before. Verified: 8 badge tests pass, including two new ones covering two awards of the same level under different keys, and a null key from an older client. The rest of the suite does not compile on this branch's base and was excluded from the run, unchanged. --- .../com/iemr/flw/domain/iemr/BadgeEarned.java | 21 ++++++++- .../com/iemr/flw/dto/iemr/BadgeEarnedDTO.java | 7 +++ .../iemr/flw/repo/iemr/BadgeEarnedRepo.java | 3 +- .../com/iemr/flw/service/BadgeService.java | 17 +++++-- .../flw/controller/BadgeControllerTest.java | 2 +- .../iemr/flw/service/BadgeServiceTest.java | 46 +++++++++++++++++-- 6 files changed, 84 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java b/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java index b73864257..382113f94 100644 --- a/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java +++ b/src/main/java/com/iemr/flw/domain/iemr/BadgeEarned.java @@ -13,13 +13,18 @@ * Append-only badge award log (Badge LLD §4.1, "once earned, never revoked"). * The unique key mirrors the device's local constraint so re-uploads after a * reinstall or a retried sync are idempotent. + * + * The key includes award_key because (user, badge, level) is not unique for every badge. + * Quarterly badges are re-earned each quarter at the same level, and per-case badges are + * earned once per beneficiary, so without it the second and later awards collapse into the + * first on upload and cannot be told apart on restore. */ @Entity @Data @Table(name = "badge_earned", schema = "db_iemr", uniqueConstraints = @UniqueConstraint( - name = "uk_badge_earned_user_badge_level", - columnNames = {"user_id", "badge_id", "level"})) + name = "uk_badge_earned_user_badge_level_key", + columnNames = {"user_id", "badge_id", "level", "award_key"})) public class BadgeEarned { @Id @@ -35,6 +40,18 @@ public class BadgeEarned { @Column(name = "level", nullable = false) private Integer level; + /** + * What makes two awards of the same badge and level different: a quarter key such as + * "2026-Q3", or an opaque digest for per-case badges. Empty for streak and cumulative + * badges, which are earned once per level. + * + * Never a beneficiary identifier. The device hashes those before they are sent, so this + * column can separate two awards without the server learning who either was about + * (Badge LLD §4). + */ + @Column(name = "award_key", length = 64, nullable = false) + private String awardKey = ""; + /** Epoch millis when the device awarded it. */ @Column(name = "earned_at", nullable = false) private Long earnedAt; diff --git a/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java b/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java index 9ce8d6a79..b7bdbb5a0 100644 --- a/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java +++ b/src/main/java/com/iemr/flw/dto/iemr/BadgeEarnedDTO.java @@ -12,4 +12,11 @@ public class BadgeEarnedDTO { private String badgeId; private Integer level; private Long earnedAt; + + /** + * Stable discriminator for badges that can be earned more than once at the same level. + * A quarter key, or an opaque digest for per-case awards; empty otherwise. Never a + * beneficiary identifier — see {@link com.iemr.flw.domain.iemr.BadgeEarned#getAwardKey()}. + */ + private String awardKey; } diff --git a/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java b/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java index 219571a55..6452e6225 100644 --- a/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java +++ b/src/main/java/com/iemr/flw/repo/iemr/BadgeEarnedRepo.java @@ -10,5 +10,6 @@ public interface BadgeEarnedRepo extends JpaRepository { List findByUserIdOrderByEarnedAtAsc(Integer userId); - boolean existsByUserIdAndBadgeIdAndLevel(Integer userId, String badgeId, Integer level); + boolean existsByUserIdAndBadgeIdAndLevelAndAwardKey( + Integer userId, String badgeId, Integer level, String awardKey); } diff --git a/src/main/java/com/iemr/flw/service/BadgeService.java b/src/main/java/com/iemr/flw/service/BadgeService.java index 074ad878e..7d30fe25e 100644 --- a/src/main/java/com/iemr/flw/service/BadgeService.java +++ b/src/main/java/com/iemr/flw/service/BadgeService.java @@ -47,11 +47,19 @@ public List getFreezes(Integer userId) { public List getEarned(Integer userId) { return earnedRepo.findByUserIdOrderByEarnedAtAsc(userId).stream() - .map(e -> new BadgeEarnedDTO(e.getBadgeId(), e.getLevel(), e.getEarnedAt())) + .map(e -> new BadgeEarnedDTO( + e.getBadgeId(), e.getLevel(), e.getEarnedAt(), e.getAwardKey())) .toList(); } - /** Idempotent: rows already known for (user, badge, level) are skipped. Returns rows inserted. */ + /** + * Idempotent: rows already known for (user, badge, level, awardKey) are skipped. Returns + * rows inserted. + * + * A missing awardKey is stored as empty rather than rejected, which is what a streak or + * cumulative badge sends and also what an older client sends for everything. That client + * then behaves exactly as it did before this field existed. + */ @Transactional public int saveEarned(Integer userId, List badges) { if (badges == null || badges.isEmpty()) return 0; @@ -59,11 +67,14 @@ public int saveEarned(Integer userId, List badges) { int inserted = 0; for (BadgeEarnedDTO dto : badges) { if (dto == null || dto.getBadgeId() == null || dto.getLevel() == null) continue; - if (earnedRepo.existsByUserIdAndBadgeIdAndLevel(userId, dto.getBadgeId(), dto.getLevel())) continue; + String awardKey = dto.getAwardKey() != null ? dto.getAwardKey() : ""; + if (earnedRepo.existsByUserIdAndBadgeIdAndLevelAndAwardKey( + userId, dto.getBadgeId(), dto.getLevel(), awardKey)) continue; BadgeEarned row = new BadgeEarned(); row.setUserId(userId); row.setBadgeId(dto.getBadgeId()); row.setLevel(dto.getLevel()); + row.setAwardKey(awardKey); row.setEarnedAt(dto.getEarnedAt() != null ? dto.getEarnedAt() : now); row.setReceivedAt(now); earnedRepo.save(row); diff --git a/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java b/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java index bb6069936..4e61d0b52 100644 --- a/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java +++ b/src/test/java/com/iemr/flw/controller/BadgeControllerTest.java @@ -70,7 +70,7 @@ void earned_usesUserIdFromJwtNotFromBody() throws Exception { @Test void getEarned_returnsListUnderEarned() throws Exception { when(jwtUtil.extractUserId("tok")).thenReturn(960); - when(badgeService.getEarned(960)).thenReturn(List.of(new BadgeEarnedDTO("timely_reporter", 1, 5L))); + when(badgeService.getEarned(960)).thenReturn(List.of(new BadgeEarnedDTO("timely_reporter", 1, 5L, ""))); mockMvc.perform(get("/badges/earned").header("JwtToken", "tok")) .andExpect(status().isOk()) diff --git a/src/test/java/com/iemr/flw/service/BadgeServiceTest.java b/src/test/java/com/iemr/flw/service/BadgeServiceTest.java index b1e7ac384..217ac1eeb 100644 --- a/src/test/java/com/iemr/flw/service/BadgeServiceTest.java +++ b/src/test/java/com/iemr/flw/service/BadgeServiceTest.java @@ -8,12 +8,15 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mock; +import org.mockito.ArgumentCaptor; import org.mockito.MockitoAnnotations; import java.util.List; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; @@ -35,21 +38,54 @@ void setUp() { @Test void saveEarned_skipsRowsAlreadyKnown_idempotentReupload() { - when(earnedRepo.existsByUserIdAndBadgeIdAndLevel(960, "steady_syncer", 1)).thenReturn(true); - when(earnedRepo.existsByUserIdAndBadgeIdAndLevel(960, "steady_syncer", 2)).thenReturn(false); + when(earnedRepo.existsByUserIdAndBadgeIdAndLevelAndAwardKey(960, "steady_syncer", 1, "")) + .thenReturn(true); + when(earnedRepo.existsByUserIdAndBadgeIdAndLevelAndAwardKey(960, "steady_syncer", 2, "")) + .thenReturn(false); int inserted = service.saveEarned(960, List.of( - new BadgeEarnedDTO("steady_syncer", 1, 10L), - new BadgeEarnedDTO("steady_syncer", 2, 20L))); + new BadgeEarnedDTO("steady_syncer", 1, 10L, ""), + new BadgeEarnedDTO("steady_syncer", 2, 20L, ""))); assertEquals(1, inserted); verify(earnedRepo, times(1)).save(any(BadgeEarned.class)); } + /** + * The whole point of the award key: a quarterly badge earned in two quarters is two + * awards at the same level, and without the key the second one is silently dropped. + */ + @Test + void saveEarned_keepsTwoAwardsOfTheSameLevelWithDifferentKeys() { + when(earnedRepo.existsByUserIdAndBadgeIdAndLevelAndAwardKey( + eq(960), eq("complete_worker"), eq(1), anyString())).thenReturn(false); + + int inserted = service.saveEarned(960, List.of( + new BadgeEarnedDTO("complete_worker", 1, 10L, "2026-Q2"), + new BadgeEarnedDTO("complete_worker", 1, 20L, "2026-Q3"))); + + assertEquals(2, inserted); + verify(earnedRepo, times(2)).save(any(BadgeEarned.class)); + } + + /** An older client sends no key at all; it must behave as it did before the field existed. */ + @Test + void saveEarned_treatsAMissingAwardKeyAsEmpty() { + when(earnedRepo.existsByUserIdAndBadgeIdAndLevelAndAwardKey(960, "steady_syncer", 1, "")) + .thenReturn(false); + + assertEquals(1, service.saveEarned(960, List.of( + new BadgeEarnedDTO("steady_syncer", 1, 10L, null)))); + + ArgumentCaptor saved = ArgumentCaptor.forClass(BadgeEarned.class); + verify(earnedRepo).save(saved.capture()); + assertEquals("", saved.getValue().getAwardKey()); + } + @Test void saveEarned_ignoresMalformedEntriesAndEmptyLists() { assertEquals(0, service.saveEarned(960, null)); - assertEquals(0, service.saveEarned(960, List.of(new BadgeEarnedDTO(null, null, null)))); + assertEquals(0, service.saveEarned(960, List.of(new BadgeEarnedDTO(null, null, null, "")))); verify(earnedRepo, never()).save(any()); } }