throw new AlurKerjaException(404, "kompetisi_spesifikasi_wilayah_tidak_ditemukan.label", id);

kompetisi_spesifikasi_wilayah_tidak_ditemukan.label = Kompetisi spesifikasi wilayah dengan ID {0} tidak ditemukan.

@GetMapping("/test-ex")
public ResponseEntity<Object> testException() {
    throw new HttpMessageNotReadableException("testException");
}

httpMessageNotReadableException = Error Baru

@RestController
@RequestMapping("/crud/vulner")
public class VulnerController extends CrudController<ScanResult, VulnerDto, VulnerService, ScanResultRepository> {

    @Autowired
    MinioService minioService;

    @Autowired
    ScanResultRepository scanResultRepository;
    @Autowired
    RemediationDocumentRepository remediationDocumentRepository;
    protected VulnerController(VulnerService crudService) { super(crudService); }

    @PostMapping("/uploadremediation")
    public ResponseEntity<Object> getUploadLinkRemediation (@RequestPart("file") MultipartFile[] files) throws AlurKerjaException {
        List<MinioDto> listMinio = new ArrayList<>();
        List<String> allowedContentTypes = Arrays.asList(
                "application/pdf",
                "application/vnd.ms-excel",
                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                "application/msword",
                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                "text/csv");

        for (MultipartFile file : files) {
            // if file size more than 5MB
            if (file.getSize() > 5242880) {throw new AlurKerjaException(400, "Maximum file size is 5MB");}

            if (!allowedContentTypes.contains(file.getContentType())) {
                throw new AlurKerjaException(400, "Invalid file type. Only PDF, Excel, Word and CSV files are allowed.");
            }
            
            listMinio.add( minioService.getUploadLink("remediation", file.getOriginalFilename(), file.getContentType()));
        }

        return this.success(listMinio, "Ok");
    }
}

@ExtendWith(SpringExtension.class)
@WebMvcTest(VulnerController.class)
@ContextConfiguration(classes = {VulnerController.class, CurrentUser.class})
class VulnerControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private VulnerService mockCrudService;
    @MockBean
    private MinioService mockMinioService;
    @MockBean
    private ScanResultRepository mockScanResultRepository;
    @MockBean
    private RemediationDocumentRepository mockRemediationDocumentRepository;

    @Test
    void testGetUploadLinkRemediation() throws Exception {
        // Setup
        // Configure MinioService.getUploadLink(...).
        final MinioDto minioDto = new MinioDto();
        minioDto.setOriginalFileName("originalFileName");
        minioDto.setIdentifier(UUID.fromString("3f13acea-040d-411b-89d7-6464946cd669"));
        minioDto.setFilePath("filePath");
        minioDto.setMediaType("mediaType");
        minioDto.setUploadUrl("uploadUrl");
        when(mockMinioService.getUploadLink(any(), any(), any())).thenReturn(minioDto);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(multipart("/crud/vulner/uploadremediation")
                        .file(new MockMultipartFile("file", "originalFilename.pdf", MediaType.APPLICATION_PDF_VALUE,
                                "content".getBytes()))
                        .accept(MediaType.APPLICATION_JSON))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("{\"status\":200,\"message\":\"Ok\",\"data\":[{\"originalFileName\":\"originalFileName\",\"identifier\":\"3f13acea-040d-411b-89d7-6464946cd669\",\"filePath\":\"filePath\",\"mediaType\":\"mediaType\",\"uploadUrl\":\"uploadUrl\"}]}");
    }
}

@Service
public class VulnerService extends CrudService<ScanResult, VulnerDto, ScanResultRepository> {
    private static final Logger logger = LoggerFactory.getLogger(VulnerService.class.getName());
    @Autowired
    CurrentUser currentUser;
    @Autowired
    RemediationDocumentRepository remediationDocumentRepository;
    @Autowired
    NotificationRepository notificationRepository;
    @Autowired
    EmailService emailService;
    @Autowired
    UserRepository userRepository;
    @Autowired
    AgingRepository agingRepository;

    @Value("${it_security_frontend_url}")
    private String feLink;
    private final ScanResultRepository scanResultRepository;

    protected VulnerService(ScanResultRepository simpleJpaRepository,
                            ScanResultRepository scanResultRepository) { super(simpleJpaRepository);
        this.scanResultRepository = scanResultRepository;
    }

    @Override
    public String getCurrentUser() {
        return currentUser.getUserId();
    }
}

@ExtendWith(MockitoExtension.class)
class VulnerServiceTest {

    @Mock
    private ScanResultRepository mockSimpleJpaRepository;
    @Mock
    private ScanResultRepository mockScanResultRepository;
    @Mock
    private CurrentUser mockCurrentUser;
    @Mock
    private RemediationDocumentRepository mockRemediationDocumentRepository;
    @Mock
    private NotificationRepository mockNotificationRepository;
    @Mock
    private EmailService mockEmailService;
    @Mock
    private UserRepository mockUserRepository;
    @Mock
    private AgingRepository mockAgingRepository;

    private VulnerService vulnerServiceUnderTest;

    @BeforeEach
    void setUp() {
        vulnerServiceUnderTest = new VulnerService(mockSimpleJpaRepository, mockScanResultRepository);
        ReflectionTestUtils.setField(vulnerServiceUnderTest, "feLink", "feLink");
        vulnerServiceUnderTest.currentUser = mockCurrentUser;
        vulnerServiceUnderTest.remediationDocumentRepository = mockRemediationDocumentRepository;
        vulnerServiceUnderTest.notificationRepository = mockNotificationRepository;
        vulnerServiceUnderTest.emailService = mockEmailService;
        vulnerServiceUnderTest.userRepository = mockUserRepository;
        vulnerServiceUnderTest.agingRepository = mockAgingRepository;
    }

    @Test
    void testGetCurrentUser() {
        // Setup
        when(mockCurrentUser.getUserId()).thenReturn("Reminder");

        // Run the test
        final String result = vulnerServiceUnderTest.getCurrentUser();

        // Verify the results
        assertThat(result).isEqualTo("Reminder");
    }
}

public class UserSpecification extends BaseSearchSpecification<User, UserDto> {
    protected UserSpecification(UserDto dto) {
        super(dto);
    }

    public UserSpecification create(UserDto dto){
        UserSpecification specifications = new UserSpecification(dto);
        specifications.buildSpecification(dto);
        return specifications;
    }

    @Override
    public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
        List<Predicate> predicates = new ArrayList<>();

        if (!ObjectUtils.isEmpty(dto.getSearch())) {
            String search = URLDecoder.decode(dto.getSearch());
            search = "%" + search + "%";

            predicates.add(criteriaBuilder.and(criteriaBuilder.or(
                    criteriaBuilder.like(criteriaBuilder.lower(root.get("name")), search),
                    criteriaBuilder.like(criteriaBuilder.lower(root.get("email")), search),
                    criteriaBuilder.like(criteriaBuilder.lower(root.get("phone")), search)
            )));
        }

        BasePredicate basePredicate = new BasePredicate();
        if (!ObjectUtils.isEmpty(searchCriteriaList)) {
            predicates.addAll(
                    basePredicate.predicate(root, criteriaQuery, criteriaBuilder, this.searchCriteriaList)
            );
        }

        return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
    }
}

@ExtendWith(MockitoExtension.class)
class UserSpecificationTest {

    @Mock
    private UserDto mockDto;

    private UserSpecification userSpecificationUnderTest;

    @BeforeEach
    void setUp() {
        userSpecificationUnderTest = new UserSpecification(mockDto);
    }

    @Test
    void testCreate() {
        // Setup
        final UserDto dto = new UserDto();
        dto.setId(UUID.fromString("48d8e0a7-d941-4b39-8c19-0854cd5d95a5"));
        dto.setName("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        dto.setEmail("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        dto.setPhone("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        final RoleDto role = new RoleDto();
        role.setId(UUID.fromString("48d8e0a7-d941-4b39-8c19-0854cd5d95a5"));
        dto.setRole(role);
        dto.setWorkgroup("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        dto.setLevel("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        dto.setOrg("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        dto.setStatus("48d8e0a7-d941-4b39-8c19-0854cd5d95a5");
        dto.setSearch("search");

        // Run the test
        final UserSpecification result = userSpecificationUnderTest.create(dto);
        Assertions.assertNotNull(result);
        // Verify the results
    }

    @Test
    void testToPredicate() {
        // Setup
        final UserDto dto = new UserDto();
        dto.setSearch("search");

        Root<User> mockRoot = mock(Root.class);
        CriteriaQuery<?> mockCriteriaQuery = mock(CriteriaQuery.class);
        CriteriaBuilder mockCriteriaBuilder = mock(CriteriaBuilder.class);

        when(mockDto.getSearch()).thenReturn("search");

        // Run the test
        Predicate result = userSpecificationUnderTest.toPredicate(mockRoot, mockCriteriaQuery, mockCriteriaBuilder);
        Assertions.assertNotNull(result);
    }
}

@Getter
@Setter
public class VulnerDto extends BaseDto<ScanResult, VulnerDto> {
    @SearchQueryCriteria(ignoreGenerated = true)
    private Integer folderId;

    @SearchQueryCriteria(ignoreGenerated = true)
    private Integer scanNessusId;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String name;

    @SearchQueryCriteria(ignoreGenerated = true)
    private Integer month;

    @SearchQueryCriteria(ignoreGenerated = true)
    private Date vaDate;

    @SearchQueryCriteria(ignoreGenerated = true)
    private Integer hostId;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String riskLevel;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String system;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String protocol;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String port;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String pluginName;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String synopsis;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String detail;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String solution;

    @SearchQueryCriteria(ignoreGenerated = true)
    private Boolean isApprove;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String assetTag;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String assetOwner;

    @SearchQueryCriteria(ignoreGenerated = true)
    private Long aging;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String managedBy;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String status;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String searchAll;

    @SearchQueryCriteria(ignoreGenerated = true)
    private RavulnerDto ravulner;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String applicationFunction;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String assetSeverity;

    @SearchQueryCriteria(ignoreGenerated = true)
    private String typeVulner;

    private UUID parentId;
    private Boolean isActive;

    private Boolean isApproval;

    @Override
    public ScanResult fromDto() {
        ScanResult entity = new ScanResult();
        BeanUtils.copyProperties(this, entity, getNullPropertyNames(this));
        if (!ObjectUtils.isEmpty(ravulner)) {
            Ravulner newRavulner = new Ravulner();
            newRavulner.setId(ravulner.getId());
            entity.setRavulner(newRavulner);
        }
        return entity;
    }
}

@ExtendWith(MockitoExtension.class)
class VulnerDtoTest {

    @Mock
    private Date mockVaDate;

    private RavulnerDto ravulner;

    private VulnerDto vulnerDtoUnderTest;

    @BeforeEach
    void setUp() throws ParseException {
        ravulner = new RavulnerDto();

        // Mengeset nilai-nilai ke properti
        ravulner.setRiskLevel("High");  // asumsikan "High" sebagai level risiko
        ravulner.setSystem("Windows");  // misalnya, sistemnya adalah "Windows"
        ravulner.setServer("Server01"); // nama server
        ravulner.setName("RavulnerName"); // nama ravulner
        ravulner.setAssetTag("Asset001"); // tag aset

        // Untuk tanggal, kita perlu parsing dari string atau mendapatkannya dari sumber lain
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy");
        Date expireDate = dateFormat.parse("01-12-2023"); // misalnya, tanggal kedaluwarsa adalah 1 Desember 2023
        ravulner.setExpireDate(expireDate);

        // Informasi tentang pembuat dan tanggal
        ravulner.setCreatedBy("Admin");  // misalnya, dibuat oleh "Admin"
        ravulner.setCreatedDate(new Date()); // tanggal saat ini sebagai tanggal dibuat
        // Untuk tanggal update, bisa diset saat terjadi perubahan, misalnya kita set sama dengan tanggal dibuat untuk contoh ini
        ravulner.setUpdatedDate(new Date()); // tanggal saat ini sebagai tanggal update
        ravulner.setUpdatedBy("UpdaterName"); // nama individu atau sistem yang melakukan update

        vulnerDtoUnderTest = new VulnerDto();
        vulnerDtoUnderTest.setVaDate(mockVaDate);
        vulnerDtoUnderTest.setRavulner(ravulner);
    }

    @Test
    void testFromDto() {
        // Run the test
        final ScanResult result = vulnerDtoUnderTest.fromDto();
        Assertions.assertNotNull(result);
        Assertions.assertNotNull(result.getRavulner());
        // Verify the results
    }
}

@Entity(name = "scan_result")
@Getter
@Setter
public class ScanResult extends CrudEntity {

    private Integer folderId;
    private Integer scanNessusId;
    private String name;
    private Integer month;

    private Date vaDate;

    private Integer hostId;
    private String riskLevel;
    @Type(type = "text")
    private String system;
    private String protocol;
    private String port;
    private String pluginId;
    @Type(type = "text")
    private String pluginName;
    @Type(type = "text")
    private String synopsis;
    @Type(type = "text")
    private String detail;
    @Type(type = "text")
    private String solution;
    @Type(type = "text")
    private String pluginOutput;
    private String status;
    private Boolean isApprove;
    private String assetTag;
    private String assetOwner;
    private Long aging;
    private String managedBy;
    @Type(type = "text")
    private String reason;
    private String submitedBy;
    private String assetSeverity;
    @Type(type = "text")
    private String assetOwnerEmail;
    private String applicationFunction;
    private String typeVulner;
    private Integer monthHostStart;
    private Date hostStart;
    @Column(columnDefinition = "boolean default true")
    private Boolean isActive;
    private UUID parentId;
    @OneToOne
    private Ravulner ravulner;
    @Transient
    private List<RemediationDocument> remediationDocument;
}

class ScanResultTest {
    private ScanResult scanResultUnderTest;

    @BeforeEach
    void setUp() {
        scanResultUnderTest = new ScanResult();
    }

    @Test
    void testScanNessusIdGetterAndSetter() {
        final Integer scanNessusId = 1;
        scanResultUnderTest.setScanNessusId(scanNessusId);
        assertThat(scanResultUnderTest.getScanNessusId()).isEqualTo(scanNessusId);
    }

    @Test
    void testNameGetterAndSetter() {
        final String Name = "Name";
        scanResultUnderTest.setName(Name);
        assertThat(scanResultUnderTest.getName()).isEqualTo(Name);
    }

    @Test
    void testMonthGetterAndSetter() {
        final Integer month = 1;
        scanResultUnderTest.setMonth(month);
        assertThat(scanResultUnderTest.getMonth()).isEqualTo(month);
    }

    // and so on
}

public abstract class FTTHExcelWriter<E> extends ExcelWriter<E> {
    protected FTTHExcelWriter(List<E> entities) {
        super(entities);
    }

    protected FTTHExcelWriter() {
        super();
    }

    public abstract void getRows(Row row, E entity, XSSFWorkbook workbook);

    private static final Logger LOGGER = Logger.getLogger(FTTHExcelWriter.class.getName());
    @Override
    public byte[] exportByte() {
        Row header;
        CellStyle headerStyle;
        try (XSSFWorkbook workbook = new XSSFWorkbook()) {

            Sheet sheet = workbook.createSheet(this.getClass().getSimpleName());

            header = sheet.createRow(0);

            headerStyle = workbook.createCellStyle();
            headerStyle.setFillForegroundColor(IndexedColors.LIGHT_BLUE.getIndex());
            headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);

            int i = 0;
            for(String headerTitle : this.getHeaders()) {
                Cell headerCell = header.createCell(i++);
                headerCell.setCellValue(headerTitle);
                headerCell.setCellStyle(headerStyle);
            }
            CellStyle style = workbook.createCellStyle();
            style.setWrapText(true);

            int j = 0;
            for(E entity : this.entities) {
                sheet.autoSizeColumn(j);
                Row row = sheet.createRow(1 + j++);
                this.getRows(row, entity, workbook);
            }

            for(int columnIndex = 0; columnIndex < 99; columnIndex++) {
                sheet.autoSizeColumn(columnIndex);
            }
            ByteArrayOutputStream bos = this.createByteArrayOutputStream();

            try {
                workbook.write(bos);
            }
            finally {
                bos.close();
            }

            return bos.toByteArray();
        } catch (IOException e) {
            LOGGER.log(Level.WARNING, e.getMessage(), e);
        }
        return new byte[0];
    }

    public ByteArrayOutputStream createByteArrayOutputStream() {
        return new ByteArrayOutputStream();
    }
}

@ExtendWith(MockitoExtension.class)
class FTTHExcelWriterTest {
    private static class TestFTTHExcelWriterTest extends  FTTHExcelWriter<HomePlanning>{
        public TestFTTHExcelWriterTest(List<HomePlanning> categories) {
            super(categories);
        }
        public TestFTTHExcelWriterTest() {
            super();
        }

        @Override
        public void getRows(Row row, HomePlanning entity, XSSFWorkbook workbook) {

        }

        @Override
        public List<String> getHeaders() {
            ArrayList<String> headers = new ArrayList<>();
            headers.add("Status");
            headers.add("SPK Number");
            headers.add("FLP Partner");
            headers.add("PKS No");
            headers.add("Cleanlist Grand Total");
            headers.add("Created Date");
            headers.add("Created By");
            headers.add("Approved Date");
            headers.add("Approved By");
            return headers;
        }

    }

    private TestFTTHExcelWriterTest ftthExcelWriterTest;

    @Test
    void testConstructorWithArgs() {
        final HomePlanning homePlanning = new HomePlanning();
        homePlanning.setCreatedDate(new GregorianCalendar(2020, Calendar.JANUARY, 1).getTime());
        homePlanning.setCreatedBy("createdBy");
        homePlanning.setApprovedDate(new GregorianCalendar(2020, Calendar.JANUARY, 1).getTime());
        homePlanning.setApprovedBy("approvedBy");
        homePlanning.setSpkNumber("spkNumber");
        homePlanning.setPksNo("pksNo");
        homePlanning.setStatus("status");
        homePlanning.setGrandTotalHomepass(new BigInteger("100"));
        final List<HomePlanning> categories = Arrays.asList(homePlanning);
        ftthExcelWriterTest = new TestFTTHExcelWriterTest(categories);
        assertThat(ftthExcelWriterTest).isNotNull();
    }

    @Test
    void testConstructorWithoutArgs(){
        ftthExcelWriterTest = new TestFTTHExcelWriterTest();
        assertThat(ftthExcelWriterTest).isNotNull();
    }

    @Test
    void testExportByte() {
        final HomePlanning homePlanning = new HomePlanning();
        homePlanning.setCreatedDate(new GregorianCalendar(2020, Calendar.JANUARY, 1).getTime());
        homePlanning.setCreatedBy("createdBy");
        homePlanning.setApprovedDate(new GregorianCalendar(2020, Calendar.JANUARY, 1).getTime());
        homePlanning.setApprovedBy("approvedBy");
        homePlanning.setSpkNumber("spkNumber");
        homePlanning.setPksNo("pksNo");
        homePlanning.setStatus("status");
        homePlanning.setGrandTotalHomepass(new BigInteger("100"));
        final List<HomePlanning> categories = Arrays.asList(homePlanning);
        ftthExcelWriterTest = new TestFTTHExcelWriterTest(categories);
        assertThat(ftthExcelWriterTest.exportByte()).isNotNull();
    }

    @Test
    void testExportByteIOException() throws IOException {
        final HomePlanning homePlanning = new HomePlanning();
        final List<HomePlanning> categories = Arrays.asList(homePlanning);
        ftthExcelWriterTest = spy(new TestFTTHExcelWriterTest(categories));
        ByteArrayOutputStream byteArrayOutputStream = mock(ByteArrayOutputStream.class);
        doReturn(byteArrayOutputStream).when(ftthExcelWriterTest).createByteArrayOutputStream();
        doThrow(new IOException("IO Exception")).when(byteArrayOutputStream).close();
        assertThat(ftthExcelWriterTest.exportByte()).isNotNull();
    }
}

public class HpdbDocFromExcel extends ExcelReader<Hpdb> {
    @Override
    public int skippedRow() {
        return 0;
    }

    @Override
    public List<Hpdb> readXlsx(InputStream file) throws IOException {
        Workbook workbook = new XSSFWorkbook(file);
        Sheet sheet;
        try{
            sheet = workbook.getSheetAt(2);
        } catch (IllegalArgumentException e){
            throw new BadRequestException("HPDB data in HPDB List excel file must be on the third sheet");
        }

        List<Hpdb> result = new ArrayList<>();
        int i = 0;

        try{
            Iterator<Row> rowIterator = sheet.rowIterator();
            while (rowIterator.hasNext()) {
                Row row = rowIterator.next();
                if (i > this.skippedRow()) {
                    ArrayList<Object> columns = new ArrayList<>();
                    Iterator<Cell> cellIterator = row.cellIterator();
                    while (cellIterator.hasNext()) {
                        Cell cell = cellIterator.next();
                        if (cell.getCellType().name().equals("NUMERIC")) {
                            columns.add(cell.getNumericCellValue());
                        } else {
                            columns.add(cell.getStringCellValue());
                        }
                    }
                    result.add(this.perLine(columns.toArray()));
                }
                ++i;
            }
        } catch (Exception e){
            Sentry.captureEvent(new SentryEvent(e));
            throw new BadRequestException("The HPDB List file that you uploaded is not appropriate");
        }

        return result;
    }
}

class HpdbDocFromExcelTest {

    private HpdbDocFromExcel hpdbDocFromExcelUnderTest;

    @BeforeEach
    void setUp() {
        hpdbDocFromExcelUnderTest = new HpdbDocFromExcel();
    }

    @Test
    void testSkippedRow() {
        assertThat(hpdbDocFromExcelUnderTest.skippedRow()).isEqualTo(0);
    }

    @Test
    void testRead1() throws Exception {
        FileInputStream file = new FileInputStream("src/test/resources/hpdb/hpdb1.xlsx");

        // Run the test
        final List<Hpdb> result = hpdbDocFromExcelUnderTest.readXlsx(file);

        // Verify the results
        assertNotNull(result);
    }
}