merge branch master -> branch custom-logger

build.gradle

@@ -31,6 +31,7 @@ dependencies {
 	implementation "org.springframework.boot:spring-boot-starter-actuator"
 	implementation 'org.springframework.boot:spring-boot-starter-security'
 	implementation 'org.springframework.boot:spring-boot-starter-oauth2-resource-server'
+	implementation 'org.springframework.boot:spring-boot-starter-webflux'
 	implementation 'org.springframework.cloud:spring-cloud-starter-feign:1.4.7.RELEASE'
 	runtimeOnly 'org.postgresql:postgresql:42.6.0'
 	implementation 'org.springframework.boot:spring-boot-starter-freemarker'
@@ -47,7 +48,7 @@ dependencies {
 	testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
 	testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
 	implementation 'org.modelmapper:modelmapper:3.2.0'
-	implementation 'commons-fileupload:commons-fileupload:1.4'
+	//implementation 'commons-fileupload:commons-fileupload:1.4'
 	implementation 'commons-codec:commons-codec:1.16.0'
 	implementation group: 'javax.validation', name: 'validation-api', version: '2.0.1.Final'
 	implementation 'org.jetbrains:annotations:24.0.1'

src/main/java/kz/project/printedFormsService/config/SecurityConfiguration.java

@@ -3,6 +3,7 @@ package kz.project.printedFormsService.config;
 
 import kz.project.printedFormsService.controller.DTemplateTypeController;
 import kz.project.printedFormsService.controller.DocumentsController;
+import kz.project.printedFormsService.controller.GitlabTemplateController;
 import kz.project.printedFormsService.controller.TemplateController;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -86,6 +87,12 @@ public class SecurityConfiguration {
                 .requestMatchers(DocumentsController.BY_TEMPLATE)
                 .hasAnyRole(CREATOR, EDITOR, DELETE, ADMIN)
 
+                .requestMatchers(GitlabTemplateController.SAVE)
+                .hasAnyRole(CREATOR, ADMIN)
+
+                .requestMatchers(GitlabTemplateController.EDIT)
+                .hasAnyRole(EDITOR, ADMIN)
+
                 .anyRequest().authenticated()
         );
 

src/main/java/kz/project/printedFormsService/controller/GitlabTemplateController.java

+package kz.project.printedFormsService.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import kz.project.printedFormsService.data.dto.GitlabUploadRequest;
+import kz.project.printedFormsService.data.dto.TemplateDto;
+import kz.project.printedFormsService.data.dto.TemplateResponseDto;
+import kz.project.printedFormsService.exception.ValidationException;
+import kz.project.printedFormsService.service.GitlabTemplateService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.io.IOException;
+
+@RestController
+@RequiredArgsConstructor
+@Slf4j
+@Tag(name = "Gitlab Template Controller", description = "API GitlabTemplateService")
+public class GitlabTemplateController {
+
+    public static final String BASE_PATH = "/api/gitlabTemplate";
+    public static final String SAVE = BASE_PATH + "/save";
+    public static final String EDIT = BASE_PATH + "/edit";
+
+    private final GitlabTemplateService gitlabTemplateService;
+
+
+    @PostMapping(SAVE)
+    @Operation(description = "Метод сохранения шаблона")
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "Данные получены успешно",
+                    content = {
+                            @Content(
+                                    mediaType = "application/json",
+
+                                    schema = @Schema(implementation = TemplateDto.class))
+                    }),
+
+
+            @ApiResponse(
+                    responseCode = "400",
+                    description = "Ошибка сервиса",
+                    content = {
+                            @Content(
+                                    mediaType = "application/json",
+
+                                    schema = @Schema(implementation = ValidationException.class))
+                    })
+    })
+    public ResponseEntity<TemplateDto> saveTemplate(
+            @RequestBody @Validated GitlabUploadRequest request
+    ) throws IOException, ValidationException {
+        return ResponseEntity.ok(gitlabTemplateService.saveFromGitlab(request));
+
+    }
+
+
+    @PutMapping(EDIT)
+    @Operation(description = "Метод редактирования шаблона")
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "Данные получены успешно",
+                    content = {
+                            @Content(
+                                    mediaType = "application/json",
+
+                                    schema = @Schema(implementation = TemplateDto.class))
+                    }),
+
+
+            @ApiResponse(
+                    responseCode = "400",
+                    description = "Ошибка сервиса",
+                    content = {
+                            @Content(
+                                    mediaType = "application/json",
+
+                                    schema = @Schema(implementation = ValidationException.class))
+                    })
+    })
+    public ResponseEntity<TemplateResponseDto> editTemplate(
+            @RequestBody @Validated GitlabUploadRequest request
+    ) throws IOException, ValidationException {
+        return ResponseEntity.ok(gitlabTemplateService.updateFromGitlab(request));
+
+    }
+}

src/main/java/kz/project/printedFormsService/controller/TemplateController.java

@@ -152,9 +152,11 @@ public class TemplateController {
                                     schema = @Schema(implementation = ValidationException.class))
                     })
     })
-    public ResponseEntity seveTemplate(@Parameter(name = "data") @RequestParam(name = "data", required = false) MultipartFile data,
+    public ResponseEntity saveTemplate(@Parameter(name = "data") @RequestParam(name = "data", required = false) MultipartFile data,
                                                     @Parameter(name = "header") @RequestParam(name = "header", required = false) MultipartFile header,
                                                     @RequestParam TemplateDto dto
+
+
     ) throws IOException, ValidationException {
         try {
             if (data == null) {
@@ -167,11 +169,12 @@ public class TemplateController {
             }
         } catch (Exception e){
             LOGGER.error(e.getMessage(), e);
-            processLogger.error(this.getClass(), new Throwable().getStackTrace()[0].getMethodName(), "Сохранение шаблона");
+            processLogger.start(this.getClass(), new Throwable().getStackTrace()[0].getMethodName(), "Сохранение шаблона");
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
         }
     }
 
+
     @PutMapping(EDIT)
     @Operation(description = "Метод для сохранение изменения")
     @ApiResponses(value = {

src/main/java/kz/project/printedFormsService/data/dto/GitlabMultipartFile.java

+package kz.project.printedFormsService.data.dto;
+
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.InputStream;
+
+@Data
+@RequiredArgsConstructor
+public class GitlabMultipartFile implements MultipartFile {
+
+    private final String name;
+    private final String originalFilename;
+    private final String contentType;
+    private final byte[] bytes;
+
+    @Override
+    public @NotNull String getName() {
+        return name;
+    }
+
+    @Override
+    public String getOriginalFilename() {
+        return originalFilename;
+    }
+
+    @Override
+    public String getContentType() {
+        return contentType;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return bytes.length == 0;
+    }
+
+    @Override
+    public long getSize() {
+        return bytes.length;
+    }
+
+    @Override
+    public byte @NotNull [] getBytes() {
+        return bytes;
+    }
+
+    @Override
+    public @NotNull InputStream getInputStream() {
+        return new ByteArrayInputStream(bytes);
+    }
+
+    @Override
+    public void transferTo(File dest) {
+
+    }
+}

src/main/java/kz/project/printedFormsService/data/dto/GitlabUploadRequest.java

+package kz.project.printedFormsService.data.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+@Data
+public class GitlabUploadRequest {
+
+    @NotBlank
+    private String repository;
+
+    @NotBlank
+    private String fileDataPath;
+
+    private String fileHeaderPath;
+
+    @NotBlank
+    private String fileDtoPath;
+}

src/main/java/kz/project/printedFormsService/service/GitlabClient.java

+package kz.project.printedFormsService.service;
+
+import org.springframework.web.multipart.MultipartFile;
+import reactor.core.publisher.Mono;
+
+public interface GitlabClient {
+    Mono<byte[]> downloadFileFromGitLab(String projectName, String filePath);
+
+    Mono<String> downloadFileContentAsString(String projectName, String filePath);
+
+    MultipartFile downloadFileAsMultipartFile(String projectName, String filePath);
+}

src/main/java/kz/project/printedFormsService/service/GitlabTemplateService.java

+package kz.project.printedFormsService.service;
+
+import kz.project.printedFormsService.data.dto.GitlabUploadRequest;
+import kz.project.printedFormsService.data.dto.TemplateDto;
+import kz.project.printedFormsService.data.dto.TemplateResponseDto;
+import lombok.SneakyThrows;
+
+public interface GitlabTemplateService {
+    @SneakyThrows
+    TemplateDto saveFromGitlab(GitlabUploadRequest gitlabUploadRequest);
+
+    @SneakyThrows
+    TemplateResponseDto updateFromGitlab(GitlabUploadRequest gitlabUploadRequest);
+}

src/main/java/kz/project/printedFormsService/service/TemplateService.java

 package kz.project.printedFormsService.service;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import kz.project.printedFormsService.data.dto.TemplateDto;
 import kz.project.printedFormsService.data.dto.TemplateResponseDto;
 import kz.project.printedFormsService.data.dto.TemplateShortDto;
 import kz.project.printedFormsService.exception.ValidationException;
-import kz.project.printedFormsService.data.dto.TemplateDto;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.web.multipart.MultipartFile;

src/main/java/kz/project/printedFormsService/service/impl/GitlabClientImpl.java

+package kz.project.printedFormsService.service.impl;
+
+import kz.project.printedFormsService.data.dto.GitlabMultipartFile;
+import kz.project.printedFormsService.service.GitlabClient;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
+
+import java.io.File;
+
+@Service
+public class GitlabClientImpl implements GitlabClient {
+
+    private final WebClient webClient;
+
+    public GitlabClientImpl(@Value("${gitlab.base-url}") String baseUrl, @Value("${gitlab.token}") String token) {
+        this.webClient = WebClient.builder()
+                .baseUrl(baseUrl)
+                .defaultHeader("PRIVATE-TOKEN", token)
+                .build();
+    }
+
+    //http://gitlab.lan.arta.kz/d.ermakov/templates/-/raw/master/dto.txt?inline=false
+    @Override
+    public Mono<byte[]> downloadFileFromGitLab(String projectName, String filePath) {
+        String urlPath = String.format("/api/v4/projects/%s/repository/files/%s/raw", projectName, filePath);
+        return webClient.get()
+                .uri(uriBuilder -> uriBuilder
+                        .path(urlPath)
+                        .queryParam("ref", "master") // or the branch you want to fetch from
+                        .build())
+                .retrieve()
+                .bodyToMono(byte[].class)
+                .doOnError(error -> System.err.println("Error downloading file: " + error.getMessage()));
+    }
+
+    @Override
+    public Mono<String> downloadFileContentAsString(String projectName, String filePath) {
+        String urlPath = String.format("/api/v4/projects/%s/repository/files/%s/raw", projectName, filePath);
+        return webClient.get()
+                .uri(uriBuilder -> uriBuilder
+                        .path(urlPath)
+                        .queryParam("ref", "master") // or the branch you want to fetch from
+                        .build())
+                .retrieve()
+                .bodyToMono(String.class)
+                .doOnError(error -> System.err.println("Error downloading file: " + error.getMessage()));
+    }
+
+    @Override
+    public MultipartFile downloadFileAsMultipartFile(String projectName, String filePath) {
+        String urlPath = String.format("/api/v4/projects/%s/repository/files/%s/raw", projectName, filePath);
+        return webClient.get()
+                .uri(uriBuilder -> uriBuilder
+                        .path(urlPath)
+                        .queryParam("ref", "master") // or the branch you want to fetch from
+                        .build())
+                .retrieve()
+                .bodyToMono(byte[].class)
+                .map(bytes -> {
+                    File file = new File(filePath);
+                    return new GitlabMultipartFile(file.getName(), file.getName(), null, bytes);
+                })
+                .doOnError(error -> System.err.println("Error downloading file: " + error.getMessage()))
+                .block();
+    }
+}

src/main/java/kz/project/printedFormsService/service/impl/GitlabTemplateServiceImpl.java

+package kz.project.printedFormsService.service.impl;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import kz.project.printedFormsService.data.dto.GitlabUploadRequest;
+import kz.project.printedFormsService.data.dto.TemplateDto;
+import kz.project.printedFormsService.data.dto.TemplateResponseDto;
+import kz.project.printedFormsService.service.GitlabClient;
+import kz.project.printedFormsService.service.TemplateService;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class GitlabTemplateServiceImpl implements kz.project.printedFormsService.service.GitlabTemplateService {
+
+    private final GitlabClient gitlabClient;
+
+    private final TemplateService templateService;
+
+    private final ObjectMapper objectMapper;
+
+
+    @SneakyThrows
+    @Override
+    public TemplateDto saveFromGitlab(GitlabUploadRequest gitlabUploadRequest) {
+        List<MultipartFile> filesToSave = new ArrayList<>();
+
+        filesToSave.add(gitlabClient.downloadFileAsMultipartFile(
+                gitlabUploadRequest.getRepository(),
+                gitlabUploadRequest.getFileDataPath()
+        ));
+
+        String dtoString = gitlabClient.downloadFileContentAsString(
+                        gitlabUploadRequest.getRepository(),
+                        gitlabUploadRequest.getFileDtoPath()
+                )
+                .blockOptional()
+                .orElseThrow();
+
+        TemplateDto templateDto = objectMapper.readValue(dtoString, TemplateDto.class);
+
+        if (gitlabUploadRequest.getFileHeaderPath() != null) {
+            filesToSave.add(
+                    gitlabClient.downloadFileAsMultipartFile(
+                            gitlabUploadRequest.getRepository(),
+                            gitlabUploadRequest.getFileHeaderPath()
+                    )
+            );
+        }
+
+        return templateService.save(templateDto, filesToSave);
+    }
+
+    @SneakyThrows
+    @Override
+    public TemplateResponseDto updateFromGitlab(GitlabUploadRequest gitlabUploadRequest) {
+        List<MultipartFile> filesToSave = new ArrayList<>();
+
+        filesToSave.add(gitlabClient.downloadFileAsMultipartFile(
+                gitlabUploadRequest.getRepository(),
+                gitlabUploadRequest.getFileDataPath()
+        ));
+
+        String dtoString = gitlabClient.downloadFileContentAsString(
+                        gitlabUploadRequest.getRepository(),
+                        gitlabUploadRequest.getFileDtoPath()
+                )
+                .blockOptional()
+                .orElseThrow();
+
+        TemplateDto templateDto = objectMapper.readValue(dtoString, TemplateDto.class);
+
+        if (gitlabUploadRequest.getFileHeaderPath() != null) {
+            filesToSave.add(
+                    gitlabClient.downloadFileAsMultipartFile(
+                            gitlabUploadRequest.getRepository(),
+                            gitlabUploadRequest.getFileHeaderPath()
+                    )
+            );
+        }
+
+        return templateService.edit(templateDto, filesToSave);
+    }
+
+}

src/main/java/kz/project/printedFormsService/service/impl/TemplateServiceImpl.java

@@ -22,6 +22,7 @@ import org.springframework.web.multipart.MultipartFile;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -55,10 +56,10 @@ public class TemplateServiceImpl implements TemplateService {
         Map<String, byte[]> params = new HashMap<>();
         TemplateEntity templateEntity = repository.findById(id).orElse(null);
         if (templateEntity == null) throw new ValidationException("по данному параметру отсутствуют данные: " + id, 13);
-        TemplateDataForReportDto templ= new TemplateDataForReportDto(templateEntity.getType().getCode(), templateEntity.getTemplate().getData(), templateEntity.getTemplateHeader() != null ? templateEntity.getTemplateHeader().getData() : null);
-        params.put("type",templ.getType().getBytes(StandardCharsets.UTF_8));
+        TemplateDataForReportDto templ = new TemplateDataForReportDto(templateEntity.getType().getCode(), templateEntity.getTemplate().getData(), templateEntity.getTemplateHeader() != null ? templateEntity.getTemplateHeader().getData() : null);
+        params.put("type", templ.getType().getBytes(StandardCharsets.UTF_8));
         params.put("body", templ.getBody());
-        params.put("header",templ.getHeader());
+        params.put("header", templ.getHeader());
 
         processLogger.finish(this.getClass(), new Throwable().getStackTrace()[0].getMethodName(), "Получение шаблона по идентификатору");
         return params;
@@ -100,12 +101,12 @@ public class TemplateServiceImpl implements TemplateService {
             throw new ValidationException("Не переданы обязательные поля: templateId", 13);
         }
         if (repository.findById(dto.getTemplateId()).isEmpty())
-            throw new ValidationException("Cо значением templateId=" + dto.getTemplateId() + "запись не существует" , 13);
+            throw new ValidationException("Cо значением templateId=" + dto.getTemplateId() + "запись не существует", 13);
 
         TemplateEntity existingEntity = repository.findById(dto.getTemplateId()).get();
         TemplateEntity receivedEntity = createTemplateEntity(dto, files);
 
-        if (!existingEntity.equals(receivedEntity)){
+        if (!existingEntity.equals(receivedEntity)) {
             versionRepository.save(new TemplateEntityVersion(existingEntity));
         }
 
@@ -158,13 +159,14 @@ public class TemplateServiceImpl implements TemplateService {
         throw new ValidationException("Не переданы обязательные поля", 13);
     }
 
+
     private TemplateEntity createTemplateEntity(TemplateDto dto, List<MultipartFile> files) throws IOException, ValidationException {
         TemplateEntity templateEntity = new TemplateEntity();
         if (dto.getTemplateId() != null) {
             templateEntity.setId(dto.getTemplateId());
         }
         templateEntity.setCode(dto.getCode());
-        if (files != null && files.size() > 0 && files.get(0) != null) {
+        if (files != null && !files.isEmpty() && files.get(0) != null) {
             if (dto.getTemplateFileId() != null) {
                 templateEntity.setTemplate(updateTemplateFiles(files.get(0), dto.getTemplateFileId(), false));
             } else if (dto.getHeaderFileId() != null) {
@@ -206,7 +208,7 @@ public class TemplateServiceImpl implements TemplateService {
                 .id(templateId)
                 .name(file.getOriginalFilename())
                 .data(file.getResource().getContentAsByteArray())
-                .hash(file.getResource().getContentAsByteArray().hashCode())
+                .hash(Arrays.hashCode(file.getResource().getContentAsByteArray()))
                 .build());
     }
 

src/main/resources/application.yml

@@ -73,6 +73,7 @@ management:
     beans:
       enabled: false
 
+
 process-logger:
   file-name: templateService.log
   delimiter: " "
@@ -80,4 +81,9 @@ process-logger:
   locale: kk_KZ
   start-prefix: "Начало процесса: "
   finish-prefix: "Конец процесса: "
-  error-prefix: "Неуспешный процесс: "
\ No newline at end of file
+  error-prefix: "Неуспешный процесс: "
+
+gitlab:
+  base-url: http://gitlab.lan.arta.kz
+  token: zif-LhgdzuLtpNW7uxYs
+