Create service for exporting skill information to CSV

Author: pieperm

server/src/main/java/com/objectcomputing/checkins/services/skill_record/SkillRecord.java

@@ -0,0 +1,84 @@
+package com.objectcomputing.checkins.services.skill_record;
+
+import com.objectcomputing.checkins.services.skillcategory_skill.SkillCategorySkillId;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.data.annotation.MappedEntity;
+
+import javax.persistence.Column;
+import javax.persistence.EmbeddedId;
+import javax.persistence.Table;
+
+@MappedEntity
+@Introspected
+@Table(name = "skill_record")
+@SuppressWarnings("unused")
+public class SkillRecord {
+
+    @EmbeddedId
+    private SkillCategorySkillId skillCategorySkillId;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "description")
+    private String description;
+
+    @Column(name = "extraneous")
+    private boolean extraneous;
+
+    @Column(name = "pending")
+    private boolean pending;
+
+    @Column(name = "category_name")
+    private String categoryName;
+
+    public SkillRecord() {}
+
+    public SkillCategorySkillId getSkillCategorySkillId() {
+        return skillCategorySkillId;
+    }
+
+    public void setSkillCategorySkillId(SkillCategorySkillId skillCategorySkillId) {
+        this.skillCategorySkillId = skillCategorySkillId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public boolean isExtraneous() {
+        return extraneous;
+    }
+
+    public void setExtraneous(boolean extraneous) {
+        this.extraneous = extraneous;
+    }
+
+    public boolean isPending() {
+        return pending;
+    }
+
+    public void setPending(boolean pending) {
+        this.pending = pending;
+    }
+
+    public String getCategoryName() {
+        return categoryName;
+    }
+
+    public void setCategoryName(String categoryName) {
+        this.categoryName = categoryName;
+    }
+}

server/src/main/java/com/objectcomputing/checkins/services/skill_record/SkillRecordController.java

@@ -0,0 +1,51 @@
+package com.objectcomputing.checkins.services.skill_record;
+
+import com.objectcomputing.checkins.security.permissions.Permissions;
+import com.objectcomputing.checkins.services.permissions.RequiredPermission;
+import io.micronaut.http.HttpResponse;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpResponse;
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.annotation.Get;
+import io.micronaut.scheduling.TaskExecutors;
+import io.micronaut.security.annotation.Secured;
+import io.micronaut.security.rules.SecurityRule;
+import jakarta.inject.Named;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Scheduler;
+import reactor.core.scheduler.Schedulers;
+
+import java.io.File;
+import java.util.concurrent.ExecutorService;
+
+@Controller("/services/skills/records")
+@Secured(SecurityRule.IS_AUTHENTICATED)
+public class SkillRecordController {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SkillRecordController.class);
+    private final SkillRecordServices skillRecordServices;
+    private final Scheduler ioScheduler;
+
+    public SkillRecordController(
+            SkillRecordServices skillRecordServices,
+            @Named(TaskExecutors.IO) ExecutorService ioExecutorService) {
+        this.skillRecordServices = skillRecordServices;
+        this.ioScheduler = Schedulers.fromExecutor(ioExecutorService);
+    }
+
+    @RequiredPermission(Permissions.CAN_VIEW_SKILL_CATEGORIES)
+    @Get(value = "/csv", produces = MediaType.TEXT_CSV)
+    public Mono<MutableHttpResponse<File>> generateCsv() {
+        return Mono.defer(() -> Mono.just(skillRecordServices.generateFile()))
+                .subscribeOn(ioScheduler)
+                .map(file -> HttpResponse
+                        .ok(file)
+                        .header("Content-Disposition", String.format("attachment; filename=%s", file.getName())))
+                .onErrorResume(error -> {
+                    LOG.error("Something went terribly wrong during export... ", error);
+                    return Mono.just(HttpResponse.serverError());
+                });
+    }
+}

server/src/main/java/com/objectcomputing/checkins/services/skill_record/SkillRecordRepository.java

@@ -0,0 +1,17 @@
+package com.objectcomputing.checkins.services.skill_record;
+
+import com.objectcomputing.checkins.services.skillcategory_skill.SkillCategorySkillId;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.data.jdbc.annotation.JdbcRepository;
+import io.micronaut.data.model.query.builder.sql.Dialect;
+import io.micronaut.data.repository.CrudRepository;
+
+import java.util.List;
+
+@JdbcRepository(dialect = Dialect.POSTGRES)
+public interface SkillRecordRepository extends CrudRepository<SkillRecord, SkillCategorySkillId> {
+
+    @NonNull
+    List<SkillRecord> findAll();
+
+}

server/src/main/java/com/objectcomputing/checkins/services/skill_record/SkillRecordServices.java

@@ -0,0 +1,9 @@
+package com.objectcomputing.checkins.services.skill_record;
+
+import java.io.File;
+
+public interface SkillRecordServices {
+
+    File generateFile();
+
+}

server/src/main/java/com/objectcomputing/checkins/services/skill_record/SkillRecordServicesImpl.java

@@ -0,0 +1,40 @@
+package com.objectcomputing.checkins.services.skill_record;
+
+import jakarta.inject.Singleton;
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVPrinter;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+@Singleton
+public class SkillRecordServicesImpl implements SkillRecordServices {
+
+    private final SkillRecordRepository skillRecordRepository;
+
+    public SkillRecordServicesImpl(SkillRecordRepository skillRecordRepository) {
+        this.skillRecordRepository = skillRecordRepository;
+    }
+
+    @Override
+    public File generateFile() {
+        List<SkillRecord> skillRecords = skillRecordRepository.findAll();
+
+        String[] headers = { "name", "description", "extraneous", "pending", "category_name" };
+        CSVFormat csvFormat = CSVFormat.DEFAULT.withHeader(headers).withQuote('"');
+
+        File csvFile = new File("skill_records.csv");
+        try (final CSVPrinter printer = new CSVPrinter(new FileWriter(csvFile, StandardCharsets.UTF_8), csvFormat)) {
+            for (SkillRecord record : skillRecords) {
+                printer.printRecord(record.getName(), record.getDescription(), record.isExtraneous(), record.isPending(), record.getCategoryName());
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        return csvFile;
+    }
+}

server/src/main/java/com/objectcomputing/checkins/services/skillcategory_skill/SkillCategorySkillId.java

@@ -17,6 +17,8 @@
 @Introspected
 public class SkillCategorySkillId {
 
+    private static final UUID MARKER = UUID.fromString("6ad7baca-3741-4ae8-b45a-4b82ade40d1f");
+
     @TypeDef(type = DataType.STRING)
     @Column(name = "skillcategory_id")
     @Schema(description = "The id of the skill category", required = true)
@@ -39,13 +41,17 @@ public SkillCategorySkillId(UUID skillCategoryId, UUID skillId) {
     public SkillCategorySkillId() {}
 
     public UUID getSkillCategoryId() {
+        if (Objects.equals(skillCategoryId, MARKER)) {
+            return null;
+        }
         return skillCategoryId;
     }
 
     public UUID getSkillId() {
         return skillId;
     }
 
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

server/src/main/resources/db/common/V94__create_skill_category_table.sql

@@ -5,6 +5,7 @@ CREATE TABLE skillcategories
     name        varchar UNIQUE,
     description varchar
 );
+
 DROP TABLE if exists skillcategory_skills;
 CREATE TABLE skillcategory_skills
 (
@@ -16,3 +17,12 @@ CREATE TABLE skillcategory_skills
     constraint fk_skill_skillcategoryskills
         foreign key (skill_id) references skills(id)
 );
+
+DROP VIEW IF EXISTS skill_record;
+CREATE VIEW skill_record AS
+SELECT s.id AS skill_id,
+       COALESCE(sc.id, '6ad7baca-3741-4ae8-b45a-4b82ade40d1f') AS skillcategory_id,
+       s.name, s.description, s.extraneous, s.pending, sc.name AS category_name
+FROM skills s
+         LEFT JOIN skillcategory_skills ss ON s.id = ss.skill_id
+         LEFT JOIN skillcategories sc ON ss.skillcategory_id = sc.id;

server/src/main/resources/db/dev/R__Load_testing_data.sql

@@ -1284,4 +1284,9 @@ INSERT INTO skillcategory_skills -- Tools GIT
 values
 ('0778a8e7-21d8-4ca3-a0dc-cad676aac417', '84682de9-85a7-4bf7-b74b-e9054311a61a');
 
+INSERT INTO skillcategory_skills -- Tools CSS
+(skillcategory_id, skill_id)
+values
+('0778a8e7-21d8-4ca3-a0dc-cad676aac417', '6b56f0aa-09aa-4b09-bb81-03481af7e49f');
+
 

server/src/test/java/com/objectcomputing/checkins/services/fixture/RepositoryFixture.java

@@ -26,6 +26,7 @@
 import com.objectcomputing.checkins.services.role.member_roles.MemberRoleRepository;
 import com.objectcomputing.checkins.services.role.role_permissions.RolePermissionRepository;
 import com.objectcomputing.checkins.services.settings.SettingsRepository;
+import com.objectcomputing.checkins.services.skill_record.SkillRecordRepository;
 import com.objectcomputing.checkins.services.skillcategory.SkillCategoryRepository;
 import com.objectcomputing.checkins.services.skillcategory_skill.SkillCategorySkillRepository;
 import com.objectcomputing.checkins.services.skills.SkillRepository;
@@ -188,4 +189,8 @@ default SkillCategoryRepository getSkillCategoryRepository() {
     default SkillCategorySkillRepository getSkillCategorySkillRepository() {
         return getEmbeddedServer().getApplicationContext().getBean(SkillCategorySkillRepository.class);
     }
+
+    default SkillRecordRepository getSkillRecordRepository() {
+        return getEmbeddedServer().getApplicationContext().getBean(SkillRecordRepository.class);
+    }
 }

server/src/test/java/com/objectcomputing/checkins/services/skill_record/SkillRecordControllerTest.java

@@ -0,0 +1,56 @@
+package com.objectcomputing.checkins.services.skill_record;
+
+import com.objectcomputing.checkins.services.TestContainersSuite;
+import com.objectcomputing.checkins.services.fixture.RoleFixture;
+import com.objectcomputing.checkins.services.fixture.SkillFixture;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.HttpResponse;
+import io.micronaut.http.HttpStatus;
+import io.micronaut.http.client.HttpClient;
+import io.micronaut.http.client.annotation.Client;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+
+import static com.objectcomputing.checkins.services.role.RoleType.Constants.ADMIN_ROLE;
+import static com.objectcomputing.checkins.services.role.RoleType.Constants.MEMBER_ROLE;
+import static org.junit.jupiter.api.Assertions.*;
+
+class SkillRecordControllerTest extends TestContainersSuite implements RoleFixture, SkillFixture {
+
+    @Inject
+    @Client("/services/skills/records")
+    private HttpClient client;
+
+    @BeforeEach
+    void createRolesAndPermissions() {
+        createAndAssignRoles();
+    }
+
+    @Test
+    public void testGetSuccess() {
+        HttpRequest<?> request = HttpRequest
+                .GET("/csv")
+                .basicAuth(ADMIN_ROLE, ADMIN_ROLE);
+        HttpResponse<File> response = client.toBlocking().exchange(request, File.class);
+
+        assertEquals(HttpStatus.OK, response.getStatus());
+        assertTrue(response.getBody().isPresent());
+    }
+
+    @Test
+    public void testGetNotAllowed() {
+        HttpRequest<?> request = HttpRequest
+                .GET("/csv")
+                .basicAuth(MEMBER_ROLE, MEMBER_ROLE);
+        HttpClientResponseException responseException = assertThrows(HttpClientResponseException.class, () ->
+                client.toBlocking().exchange(request, File.class)
+        );
+
+        assertEquals(HttpStatus.FORBIDDEN, responseException.getStatus());
+    }
+
+}