diff --git a/clearing-parent/backend-api/pom.xml b/clearing-parent/backend-api/pom.xml index ad0714978..974f8f46f 100644 --- a/clearing-parent/backend-api/pom.xml +++ b/clearing-parent/backend-api/pom.xml @@ -82,6 +82,11 @@ assertj-core test + + org.reflections + reflections + 0.9.11 + diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/MetaConfiguration.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/MetaConfiguration.java index 96e961be5..515707844 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/MetaConfiguration.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/MetaConfiguration.java @@ -1,9 +1,16 @@ package ru.spcex.clearing.backendapi.config; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.io.Resource; +import ru.spcex.clearing.backendapi.meta.MetaServer; import java.io.IOException; import java.nio.file.Files; @@ -18,4 +25,15 @@ public class MetaConfiguration { if (!meta.isReadable()) throw new IllegalStateException("cannot read meta.json from spring.config.location"); return Files.readString(meta.getFile().toPath()); } + + @Autowired + @Bean + public MetaServer metaServer(@Qualifier("metaJson") String metaJson) throws JsonProcessingException { + ObjectMapper jsonObjectMapper = new ObjectMapper(); + jsonObjectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true); + jsonObjectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + MetaServer metaServer = jsonObjectMapper.readValue(metaJson, MetaServer.class); + metaServer.initAndValidate(); + return metaServer; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountController.java index 6d391a03c..8aae9a920 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.account.Account; -import ru.spcex.clearing.backendapi.controller.response.entity.account.AccountBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/accounting/accounts") @@ -26,12 +27,12 @@ public class AccountController { } @ApiOperation(value = "get all accounts.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = AccountBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public AccountBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_Account, Account.class); - AccountBackendGetAll response = new AccountBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Account, Account.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/BankAccountController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/BankAccountController.java index a3ce6408e..b2442db7b 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/BankAccountController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/BankAccountController.java @@ -15,7 +15,7 @@ import ru.spcex.clearing.backendapi.controller.request.cud.account.BankAccountUp import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.account.BankAccountBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.controller.response.entity.account.BankAccountBackendGetById; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; @@ -23,6 +23,7 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.Optional; import java.util.concurrent.ExecutionException; @@ -84,12 +85,12 @@ public class BankAccountController extends AbstractQueueController { } @ApiOperation(value = "get all bank accounts.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = BankAccountBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public BankAccountBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_BankAccount, BankAccount.class); - BankAccountBackendGetAll response = new BankAccountBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_BankAccount, BankAccount.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java index d92c9e413..35dcd9432 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java @@ -14,13 +14,14 @@ import ru.clearing.classes.statics.data.company.Company; import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.company.CompanyBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.concurrent.ExecutionException; @Controller @@ -46,12 +47,12 @@ public class DeleteCompanyController extends AbstractQueueController { } @ApiOperation(value = "get all Company's.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CompanyBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public CompanyBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_Company, Company.class); - CompanyBackendGetAll response = new CompanyBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Company, Company.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditClearingMemberCategoryController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditClearingMemberCategoryController.java index c97c71b17..e7f84d5b6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditClearingMemberCategoryController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditClearingMemberCategoryController.java @@ -15,13 +15,14 @@ import ru.spcex.clearing.backendapi.controller.request.cud.company.ClearingMembe import ru.spcex.clearing.backendapi.controller.request.cud.company.ClearingMemberCategoryUpdateAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.company.ClearingMemberCategoryBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.concurrent.ExecutionException; @Controller @@ -70,12 +71,12 @@ public class EditClearingMemberCategoryController extends AbstractQueueControlle } @ApiOperation(value = "get all ClearingMemberCategories.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = ClearingMemberCategoryBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public ClearingMemberCategoryBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class); - ClearingMemberCategoryBackendGetAll response = new ClearingMemberCategoryBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanySymbolController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanySymbolController.java index c7972194e..c9c2bd8fd 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanySymbolController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanySymbolController.java @@ -13,13 +13,14 @@ import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; import ru.spcex.clearing.backendapi.controller.request.cud.company.CompanySymbolUpdateAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.company.CompanySymbolsBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.concurrent.ExecutionException; @Controller @@ -48,12 +49,12 @@ public class EditCompanySymbolController extends AbstractQueueController { } @ApiOperation(value = "get all CompanySymbols") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CompanySymbolsBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public CompanySymbolsBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); - CompanySymbolsBackendGetAll response = new CompanySymbolsBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditContactController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditContactController.java index f999430be..6ac2abd0e 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditContactController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditContactController.java @@ -13,13 +13,14 @@ import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; import ru.spcex.clearing.backendapi.controller.request.cud.company.ContactUpdateAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.company.ContactBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.concurrent.ExecutionException; @Controller @@ -47,12 +48,12 @@ public class EditContactController extends AbstractQueueController { } @ApiOperation(value = "get all Contacts.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = ContactBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public ContactBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_Contact, Contact.class); - ContactBackendGetAll response = new ContactBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Contact, Contact.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java index 0a69a82b6..1e1909a53 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.profile.ProfileDocument; -import ru.spcex.clearing.backendapi.controller.response.entity.company.ProfileDocumentBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/profile-documents") @@ -26,12 +27,12 @@ public class ProfileDocumentController { } @ApiOperation(value = "get all ProfileDocuments.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = ProfileDocumentBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public ProfileDocumentBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_ProfileDocument, ProfileDocument.class); - ProfileDocumentBackendGetAll response = new ProfileDocumentBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_ProfileDocument, ProfileDocument.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerAllTodayController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerAllTodayController.java index 64d9771d8..566a2385f 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerAllTodayController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerAllTodayController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.scheduler.SchedulerAllToday; -import ru.spcex.clearing.backendapi.controller.response.entity.schedule.SchedulerAllTodayBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/schedule/schedulers-all-today") @@ -26,12 +27,12 @@ public class SchedulerAllTodayController { } @ApiOperation(value = "get all SchedulerAllToday objects.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = SchedulerAllTodayBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public SchedulerAllTodayBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_SchedulerAllToday, SchedulerAllToday.class); - var response = new SchedulerAllTodayBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_SchedulerAllToday, SchedulerAllToday.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerController.java index f66311bb3..e9a611a5e 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/SchedulerController.java @@ -9,11 +9,13 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.scheduler.Scheduler; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.controller.response.entity.schedule.SchedulerBackendGetAll; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/schedule/schedulers") @@ -29,9 +31,9 @@ public class SchedulerController { @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = SchedulerBackendGetAll.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public SchedulerBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_Scheduler, Scheduler.class); - var response = new SchedulerBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Scheduler, Scheduler.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TaskRunnerController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TaskRunnerController.java index b76a1f163..22c59eeb7 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TaskRunnerController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TaskRunnerController.java @@ -17,7 +17,7 @@ import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; import ru.spcex.clearing.backendapi.controller.request.cud.schedule.TaskRunnerNew; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.schedule.TaskRunnerBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.errors.NotFound404Exception; import ru.spcex.clearing.backendapi.security.KeycloakUtils; import ru.spcex.clearing.backendapi.service.IOperator; @@ -47,12 +47,12 @@ public class TaskRunnerController extends AbstractQueueController { } @ApiOperation(value = "get all TaskRunners.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = TaskRunnerBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public TaskRunnerBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_TaskRunner, TaskRunner.class); - var response = new TaskRunnerBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_TaskRunner, TaskRunner.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TimeTableController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TimeTableController.java index deb2d33a3..0c24dc073 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TimeTableController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TimeTableController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.scheduler.Timetable; -import ru.spcex.clearing.backendapi.controller.response.entity.schedule.TimetableBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/schedule/timetables") @@ -26,12 +27,12 @@ public class TimeTableController { } @ApiOperation(value = "get all Timetables.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = TimetableBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public TimetableBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_Timetable, Timetable.class); - var response = new TimetableBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Timetable, Timetable.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TradingCalendarController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TradingCalendarController.java index 51bd604e7..69c166d8c 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TradingCalendarController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/TradingCalendarController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.scheduler.TradingCalendar; -import ru.spcex.clearing.backendapi.controller.response.entity.schedule.TradingCalendarBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/schedule/trading-calendars") @@ -26,12 +27,12 @@ public class TradingCalendarController { } @ApiOperation(value = "get all trading calendars.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = TradingCalendarBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public TradingCalendarBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_TradingCalendar, TradingCalendar.class); - var response = new TradingCalendarBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_TradingCalendar, TradingCalendar.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java index 3103aab14..7feceaedb 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java @@ -15,13 +15,14 @@ import ru.spcex.clearing.backendapi.controller.request.cud.securities.MoneyMarke import ru.spcex.clearing.backendapi.controller.request.cud.securities.MoneyMarketSecurityUpdateAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.securities.MoneyMarketSecurityBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.concurrent.ExecutionException; @Controller @@ -70,12 +71,12 @@ public class CudMoneyMarketSecurityController extends AbstractQueueController { } @ApiOperation(value = "get all money market securities.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = MoneyMarketSecurityBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public MoneyMarketSecurityBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class); - MoneyMarketSecurityBackendGetAll response = new MoneyMarketSecurityBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java index 6d310b0f8..faa52dc3a 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.user.User; -import ru.spcex.clearing.backendapi.controller.response.entity.user.UserBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/users") @@ -26,12 +27,12 @@ public class UserController { } @ApiOperation(value = "get all users.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = UserBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public UserBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_User, User.class); - var response = new UserBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_User, User.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserRoleSessionController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserRoleSessionController.java index 3fcaedd44..e783e929b 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserRoleSessionController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserRoleSessionController.java @@ -9,11 +9,12 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.user.UserRoleSession; -import ru.spcex.clearing.backendapi.controller.response.entity.user.UserRoleSessionBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; +import java.util.Map; @Controller @RequestMapping("/user-role-sessions") @@ -26,12 +27,12 @@ public class UserRoleSessionController { } @ApiOperation(value = "get all user role sessions.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = UserRoleSessionBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public UserRoleSessionBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class); - var response = new UserRoleSessionBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/CudKeyRateController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/CudKeyRateController.java index 80c5a02d3..903fb1740 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/CudKeyRateController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/CudKeyRateController.java @@ -15,13 +15,14 @@ import ru.spcex.clearing.backendapi.controller.request.cud.utilities.KeyRateNewA import ru.spcex.clearing.backendapi.controller.request.cud.utilities.KeyRateUpdateAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.utilities.KeyRateBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; import java.util.Collection; +import java.util.Map; import java.util.concurrent.ExecutionException; @Controller @@ -70,12 +71,12 @@ public class CudKeyRateController extends AbstractQueueController { } @ApiOperation(value = "get all KeyRate's.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = KeyRateBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public KeyRateBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_KeyRate, KeyRate.class); - KeyRateBackendGetAll response = new KeyRateBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_KeyRate, KeyRate.class); + CommonGetAllResponse response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/UserSettingsController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/UserSettingsController.java index 7a52b494b..bb68fb9b3 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/UserSettingsController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/UserSettingsController.java @@ -19,7 +19,7 @@ import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserSettingsUpdateAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; -import ru.spcex.clearing.backendapi.controller.response.entity.user.UserSettingsBackendGetAll; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.security.KeycloakUtils; import ru.spcex.clearing.backendapi.service.IOperator; import ru.spcex.clearing.backendapi.service.IStateLoader; @@ -46,12 +46,12 @@ public class UserSettingsController extends AbstractQueueController { } @ApiOperation(value = "get all user settings.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = UserSettingsBackendGetAll.class)}) + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(method = RequestMethod.GET) @ResponseBody - public UserSettingsBackendGetAll getAll() { - Collection all = stateLoader.getAll(IMDGDistributedNames.Map_UserSettings, UserSettings.class); - var response = new UserSettingsBackendGetAll(); + public CommonGetAllResponse getAll() { + Collection> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_UserSettings, UserSettings.class); + var response = new CommonGetAllResponse(); response.fromEntity(all); return response; } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetAllResponse.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetAllResponse.java new file mode 100644 index 000000000..7848ac5cf --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetAllResponse.java @@ -0,0 +1,46 @@ +package ru.spcex.clearing.backendapi.controller.response.entity; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +@ApiModel(description = "Ответ при получении массива объектов.") +public class CommonGetAllResponse extends BasicSpcexResponse { + + @JsonProperty + @ApiModelProperty(value = "Полезная нагрузка") + private GetAllCommonPayload payload = new GetAllCommonPayload(); + + private static class GetAllCommonPayload { + private List> items = new ArrayList<>(); + + public List> getItems() { + return items; + } + + public void setItems(List> items) { + this.items = items; + } + } + + public GetAllCommonPayload getPayload() { + return payload; + } + + public void setPayload(GetAllCommonPayload payload) { + this.payload = payload; + } + + public void fromEntity(Collection> anyObjectFields) { + var payload = this.getPayload(); + for (Map moneyMarketSecurity : anyObjectFields) { + payload.getItems().add(moneyMarketSecurity); + } + } +} \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAll.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAll.java index fecdc6a56..c19295725 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAll.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAll.java @@ -3,12 +3,12 @@ package ru.spcex.clearing.backendapi.controller.response.entity.securities; import com.fasterxml.jackson.annotation.JsonProperty; import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; -import ru.clearing.classes.statics.data.misc.MoneyMarketSecurity; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Map; @ApiModel(description = "Ответ при получении объектов MoneyMarketSecurity.") public class MoneyMarketSecurityBackendGetAll extends BasicSpcexResponse { @@ -18,13 +18,13 @@ public class MoneyMarketSecurityBackendGetAll extends BasicSpcexResponse { private MoneyMarketSecurityBackendPayload payload = new MoneyMarketSecurityBackendPayload(); private static class MoneyMarketSecurityBackendPayload { - private List items = new ArrayList<>(); + private List> items = new ArrayList<>(); - public List getItems() { + public List> getItems() { return items; } - public void setItems(List items) { + public void setItems(List> items) { this.items = items; } } @@ -37,22 +37,10 @@ public class MoneyMarketSecurityBackendGetAll extends BasicSpcexResponse { this.payload = payload; } - public void fromEntity(Collection moneyMarketSecurities) { + public void fromEntity(Collection> moneyMarketSecurities) { var payload = this.getPayload(); - for (MoneyMarketSecurity moneyMarketSecurity : moneyMarketSecurities) { - var singleItem = new MoneyMarketSecurityBackendGetFields(); - singleItem.setId(moneyMarketSecurity.getId()); - singleItem.setSecurityId(moneyMarketSecurity.getSecurityId()); - singleItem.setDescription(moneyMarketSecurity.getDescription()); - singleItem.setStartDate(moneyMarketSecurity.getStartDate()); - singleItem.setEndDate(moneyMarketSecurity.getEndDate()); - singleItem.setNominalValue(moneyMarketSecurity.getNominalValue()); - singleItem.setNominalCurrency(moneyMarketSecurity.getNominalCurrency()); - singleItem.setInstrumentType(moneyMarketSecurity.getInstrumentType()); - singleItem.setFullName(moneyMarketSecurity.getFullName()); - singleItem.setSecuritySymbol(moneyMarketSecurity.getSecuritySymbol()); - payload.getItems().add(singleItem); + for (Map moneyMarketSecurity : moneyMarketSecurities) { + payload.getItems().add(moneyMarketSecurity); } } - } \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAllOld.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAllOld.java new file mode 100644 index 000000000..0f656b8a2 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/securities/MoneyMarketSecurityBackendGetAllOld.java @@ -0,0 +1,59 @@ +package ru.spcex.clearing.backendapi.controller.response.entity.securities; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import ru.clearing.classes.statics.data.misc.MoneyMarketSecurity; +import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +@Deprecated +@ApiModel(description = "Ответ при получении объектов MoneyMarketSecurity.") +public class MoneyMarketSecurityBackendGetAllOld extends BasicSpcexResponse { + + @JsonProperty + @ApiModelProperty(value = "Полезная нагрузка") + private MoneyMarketSecurityBackendPayload payload = new MoneyMarketSecurityBackendPayload(); + + private static class MoneyMarketSecurityBackendPayload { + private List items = new ArrayList<>(); + + public List getItems() { + return items; + } + + public void setItems(List items) { + this.items = items; + } + } + + public MoneyMarketSecurityBackendPayload getPayload() { + return payload; + } + + public void setPayload(MoneyMarketSecurityBackendPayload payload) { + this.payload = payload; + } + + public void fromEntity(Collection moneyMarketSecurities) { + var payload = this.getPayload(); + for (MoneyMarketSecurity moneyMarketSecurity : moneyMarketSecurities) { + var singleItem = new MoneyMarketSecurityBackendGetFields(); + singleItem.setId(moneyMarketSecurity.getId()); + singleItem.setSecurityId(moneyMarketSecurity.getSecurityId()); + singleItem.setDescription(moneyMarketSecurity.getDescription()); + singleItem.setStartDate(moneyMarketSecurity.getStartDate()); + singleItem.setEndDate(moneyMarketSecurity.getEndDate()); + singleItem.setNominalValue(moneyMarketSecurity.getNominalValue()); + singleItem.setNominalCurrency(moneyMarketSecurity.getNominalCurrency()); + singleItem.setInstrumentType(moneyMarketSecurity.getInstrumentType()); + singleItem.setFullName(moneyMarketSecurity.getFullName()); + singleItem.setSecuritySymbol(moneyMarketSecurity.getSecuritySymbol()); + payload.getItems().add(singleItem); + } + } + +} \ No newline at end of file diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionElement.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionElement.java new file mode 100644 index 000000000..8fa0523be --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionElement.java @@ -0,0 +1,49 @@ +package ru.spcex.clearing.backendapi.meta; + + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.LinkedList; +import java.util.List; + +@SuppressWarnings({"DefaultAnnotationParam", "unused"}) +public class ActionElement { + @JsonProperty(value = "class") + private String clazz = null; + + @JsonProperty(value = "name", required = true) + private String name = null; + + @JsonProperty(value = "destination", required = false) + private String destination = null; + + @JsonProperty(value = "array", required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Boolean isArray = null; + + // @JsonProperty(value = "fields", required = true) +// private List> fields = new LinkedList<>(); + @JsonProperty(value = "fields", required = true) + private List fields = new LinkedList<>(); + + public String getName() { + return name; + } + + public List getFields() { + return fields; + } + + public String getDestination() { + return destination; + } + + public String getClazz() { + return clazz; + } + + public Boolean getArray() { + return isArray; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionField.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionField.java new file mode 100644 index 000000000..b672c14cd --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionField.java @@ -0,0 +1,118 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +import java.util.HashMap; +import java.util.Map; + +public class ActionField { + @JsonProperty(value = "code") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String code; + + @JsonProperty(value = "name") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String name; + + @JsonProperty(value = "shortname") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String shortname; + + @JsonProperty(value = "linkCode") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String linkcode; + + @JsonProperty(value = "link") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String link; + + @JsonProperty(value = "field") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String field; + + @JsonProperty(value = "length") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private Integer length; + + @JsonProperty(value = "required") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private Boolean required; + + @JsonProperty(value = "table") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private String table; + + @JsonProperty(value = "type") + @JsonDeserialize(using = MetaDataTypeDeserializer.class) + @JsonSerialize(using = MetaDataTypeSerializer.class, include = JsonSerialize.Inclusion.NON_EMPTY) + private MetaDataTypes type; + + @JsonProperty(value = "virtual") + @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY) + private Boolean virtual; + + @JsonIgnore + private Map additionalProperties = new HashMap<>(); + + public String getCode() { + return code; + } + + public String getField() { + return field; + } + + public Integer getLength() { + return length; + } + + public Boolean isRequired() { + return required; + } + + public MetaDataTypes getType() { + return type; + } + + public String getName() { + return name; + } + + public String getLink() { + return link; + } + + public String getShortname() { + return shortname; + } + + public String getLinkcode() { + return linkcode; + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + @JsonAnySetter + public void setAdditionalProperty(String name, Object value) { + this.additionalProperties.put(name, value); + } + + public Boolean isVirtual(){ + return virtual; + } + public Boolean getVirtual() { + return virtual; + } + + public void setVirtual(Boolean virtual) { + this.virtual = virtual; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingFieldExtracted.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingFieldExtracted.java new file mode 100644 index 000000000..bba9df903 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingFieldExtracted.java @@ -0,0 +1,17 @@ +package ru.spcex.clearing.backendapi.meta; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class ClearingFieldExtracted extends FieldExtracted { + static final Logger log = LoggerFactory.getLogger(ClearingFieldExtracted.class); + + public ClearingFieldExtracted(ActionField field) { + super(field); + } + + @Override + public Object getObjectRef(Object o) { + throw new IllegalStateException("unsupported operation"); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingMetaServerValidationException.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingMetaServerValidationException.java new file mode 100644 index 000000000..d55f219b3 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingMetaServerValidationException.java @@ -0,0 +1,21 @@ +package ru.spcex.clearing.backendapi.meta; + + +import ru.clearing.classes.ConstSerializable; + +public class ClearingMetaServerValidationException extends RuntimeException { + private static final long serialVersionUID = ConstSerializable.serialVersionUID; + + public ClearingMetaServerValidationException(String s) { + super(s); + } + + public ClearingMetaServerValidationException(String s, Throwable throwable) { + super(s, throwable); + } + + public ClearingMetaServerValidationException(Throwable throwable) { + super(throwable); + } + +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingObjectExtracted.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingObjectExtracted.java new file mode 100644 index 000000000..ce103ed08 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingObjectExtracted.java @@ -0,0 +1,14 @@ +package ru.spcex.clearing.backendapi.meta; + +import java.util.List; + +public class ClearingObjectExtracted extends ObjectExtracted { + public ClearingObjectExtracted(String clazz, List actionFields) { + super(clazz, actionFields); + } + + @Override + public FieldExtracted getImplFieldExtracted(ActionField field) { + return new ClearingFieldExtracted(field); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/FieldExtracted.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/FieldExtracted.java new file mode 100644 index 000000000..d3f1e4575 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/FieldExtracted.java @@ -0,0 +1,104 @@ +package ru.spcex.clearing.backendapi.meta; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.time.LocalDate; +import java.util.*; + +public abstract class FieldExtracted { + private final Logger log = LoggerFactory.getLogger(this.getClass()); + + private ActionField field; + private String memberName; + private Collection getterNames; + + public FieldExtracted(ActionField field) { + this.field = field; + this.memberName = field.getField() != null ? field.getField() : field.getCode(); + this.getterNames = gettersForField(this.memberName); + } + + public static Collection gettersForField(String fieldName) { + String[] fieldParts = fieldName.split("\\."); + List getters = new LinkedList<>(); + for (String partName : fieldParts) { + getters.add(String.format("%s%s%s", + RfHelper.GETTER_NAME_PREFIX, + partName.substring(0, 1).toUpperCase(), + partName.substring(1, partName.length()) + )); + } + return getters; + } + + @Override + public String toString() { + return String.format("%s (%s) (getters=%d)", field.getCode(), memberName, getterNames.size()); + } + + public abstract Object getObjectRef(Object o); + + public Object extractValue(Object from) + throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { + Object result = from; + for (String getterName : getGetterNames()) { + if (RfHelper.BUSINESS_OBJECT_REF.equals(result.getClass().getSimpleName()) && !RfHelper.GETTER_NAME_ID.equals(getterName)) { + Object resultNew = getObjectRef(result); + if (resultNew == null) { + log.warn("BusinessObject by referenceId does not exists!"); + break; + } + result = resultNew; + } + Method m = result.getClass().getMethod(getterName); + result = m.invoke(result); + if (result == null) + break; + } + + //fixme somehow externalize custom serialization for type + // тут нужно вернуть список id объектов а не список самих объектов для случая + // - add(r, "addresseeId", o.getAddressee() == null ? null : o.getAddressee().stream().map(OtcObjectBase::getId).collect(Collectors.toSet()), fieldFilter); + if (result instanceof Set && ((Set) result).size() > 0) { + try { + Set t = new HashSet(); + Class citem = (((Set) result).iterator().next()).getClass(); + for (Object item : (Set) result) { + t.add(citem.getMethod(RfHelper.GETTER_NAME_ID).invoke(item)); + } + result = t; + } catch (Throwable ignored) {// вернем сами объекты + } + } else if (result instanceof LocalDate) { + result = result.toString(); + } + return result; + } + + public ActionField getField() { + return field; + } + + public void setField(ActionField field) { + this.field = field; + } + + public void setMemberName(String memberName) { + this.memberName = memberName; + } + + public void setGetterNames(Collection getterNames) { + this.getterNames = getterNames; + } + + public String getMemberName() { + return memberName; + } + + public Collection getGetterNames() { + return getterNames; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java new file mode 100644 index 000000000..11299df70 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java @@ -0,0 +1,125 @@ +package ru.spcex.clearing.backendapi.meta; + +import org.apache.commons.lang3.exception.ExceptionUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.util.*; +import java.util.stream.Collectors; + +@Component +public class GetResponseFactory { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final MetaServer meta; + + @Autowired + public GetResponseFactory(MetaServer meta) { + this.meta = meta; + } + + public Collection> responseFromObjectCollection(Collection o) { + return o.stream() + .map(this::responseFromObject) + .collect(Collectors.toList()); + } + + public Map responseFromObject(Object o) { + ObjectExtracted objExtr = meta.getObjectsExtractedByClazz().get(o.getClass().getCanonicalName()); + if (objExtr == null) { + throw new RuntimeException("cannot find object in meta for " + o.getClass().getCanonicalName()); + } + Map r = new LinkedHashMap<>(); + FieldExtracted currentField = null; + try { + for (FieldExtracted field : objExtr.getFields()) { + if (field.getField().isVirtual() != null && field.getField().isVirtual()) { + continue; + } + currentField = field; +// if (fieldsToAdd.contains(field.getField().getCode())) { + try { + add(r, field.getField().getCode(), field.extractValue(o)); + } catch (Throwable e) { + log.warn(ExceptionUtils.getStackTrace( + new RuntimeException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s", + field.getField().getCode(), + o.getClass().getSimpleName(), objExtr.getClassName(), + e.getClass().getSimpleName(), e.getLocalizedMessage(), + currentField.toString() + ))) + ); + } +// } + } + } catch (Exception e) { + log.error(ExceptionUtils.getStackTrace(e)); + return null; + } + return r; + } + + private void add(Map response, String name, Object value) { + Object data; + if (value instanceof Date) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss+03:00"); + data = sdf.format(value); + } else if (value instanceof Instant) { + data = dateTimeFormatter.format((Instant) value); + } else { + data = value; + } + response.put(name, data); + } + + private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter + .ofPattern("yyyy-MM-dd'T'HH:mm:ss+03:00") + .withLocale(Locale.US) + .withZone(ZoneId.of("Europe/Moscow")); + + +// public Map newX(Object o, Collection fieldFilter, String destination) { +// ObjectExtracted targetClazz = getTargetClazz(o, destination); +// if (targetClazz == null) +// throw new FrontendException(String.format("Unknown response class: %s", o.getClass().getName())); +// Collection fieldsToAdd = getFilteredFields(targetClazz, fieldFilter); +// Map r = new LinkedHashMap<>(); +// FieldExtracted currentField = null; +// try { +// for (FieldExtracted field : targetClazz.getFields()) { +// if (field.getField().isVirtual() != null && field.getField().isVirtual()) { +// continue; +// } +// currentField = field; +// if (fieldsToAdd.contains(field.getField().getCode())) { +// try { +// add(r, field.getField().getCode(), field.extractValue(o)); +// } catch (Throwable e) { +// log.warn(ExceptionUtils.getStackTrace( +// new FrontendException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s", +// field.getField().getCode(), +// o.getClass().getSimpleName(), targetClazz.getClazz().getSimpleName(), +// e.getClass().getSimpleName(), e.getLocalizedMessage(), +// JsonHelper.writeAnyClassToLog(currentField) +// ))) +// ); +// } +// } +// } +// } catch (FrontendException e) { +// throw e; +// } catch (Throwable e) { +// throw new FrontendException(String.format("Can't get field of %s(%s): %s -> %s\n%s", +// o.getClass().getSimpleName(), targetClazz.getClazz().getSimpleName(), +// e.getClass().getSimpleName(), e.getLocalizedMessage(), +// JsonHelper.writeAnyClassToLog(currentField) +// )); +// } +// return r; +// } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaBase.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaBase.java new file mode 100644 index 000000000..641856800 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaBase.java @@ -0,0 +1,49 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.*; + +public class MetaBase { + + @JsonProperty(required = true, defaultValue = "unknown") + private String version = null; + + public String getVersion() { + return version; + } + + @JsonProperty(required = true) + private Map enums = new LinkedHashMap<>(); + + @JsonProperty(required = true) + private Map objects = new LinkedHashMap<>(); + + @JsonProperty(required = true) + private List> types = new LinkedList<>(); + + @JsonProperty + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Map views = new HashMap<>(); + + public Map getEnums() { + return enums; + } + + public Map getObjects() { + return objects; + } + + public List> getTypes() { + return types; + } + + public Map getViews() { + return views; + } + + public void setViews(Map views) { + this.views = views; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypeDeserializer.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypeDeserializer.java new file mode 100644 index 000000000..8e2672f99 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypeDeserializer.java @@ -0,0 +1,20 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonDeserializer; +import ru.spcex.platform.utils.enumeration.IEnumId; + +import java.io.IOException; + +public class MetaDataTypeDeserializer extends JsonDeserializer { + @Override + public MetaDataTypes deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { + if (p.getText() != null && p.getText().length() > 0) { + if (!"0".equals(p.getText()) && !p.getText().matches("[1-9]+[0-9]*")) return null; + Long metaDataType = new Long(p.getText()); + return IEnumId.getEnumById(MetaDataTypes.class, metaDataType); + } else return null; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypeSerializer.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypeSerializer.java new file mode 100644 index 000000000..1115c8dce --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypeSerializer.java @@ -0,0 +1,15 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +public class MetaDataTypeSerializer extends JsonSerializer { + @Override + public void serialize(MetaDataTypes metaDataTypes, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + jsonGenerator.writeNumber(metaDataTypes.getId()); + } + +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypes.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypes.java new file mode 100644 index 000000000..2e8f6c5db --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaDataTypes.java @@ -0,0 +1,52 @@ +package ru.spcex.clearing.backendapi.meta; + +import ru.spcex.platform.utils.enumeration.IEnumId; + +public enum MetaDataTypes implements IEnumId { + Identity(1L), + String(2L), + Long(3L), + DateTime(4L), + Time(5L), + Date(6L), + Array(7L), + Object(8L), + Boolean(9L), + Double(10L), + UID(11L); + + private final Long id; + + MetaDataTypes(Long id) { + this.id = id; + } + + @Override + public java.lang.Long getId() { + return this.id; + } + + public int getTypeSize() { + switch (this) { + case Long: + return java.lang.String.valueOf(java.lang.Long.MAX_VALUE).length(); + case Identity: + return java.lang.String.valueOf(java.lang.Long.MAX_VALUE).length(); + case DateTime: + return 25; + case Time: + return 25; + case Date: + return 25; + case Array: + return java.lang.String.valueOf(java.lang.Long.MAX_VALUE).length() * 400; + case Boolean: + return java.lang.Boolean.TRUE.toString().length(); + case Double: + return 18; + case UID: + return 36; + } + return 0; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java new file mode 100644 index 000000000..be7392a9b --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java @@ -0,0 +1,199 @@ +package ru.spcex.clearing.backendapi.meta; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Collectors; + +public class MetaServer extends MetaBase { + private final Logger log = LoggerFactory.getLogger(this.getClass()); + + private Collection objectsExtracted; + private Map objectsExtractedByClazz; + private Map objectsExtractedByDestination; + private Map actionObjectsExtracted; + private Map objectElementByDestination; + + protected ObjectExtracted getImplInstanceObjectExtracted(String clazz, List actionFields) { + return new ClearingObjectExtracted(clazz, actionFields); + } + + private int classNameMock = 1; + @SuppressWarnings("Duplicates") + public void initAndValidate() throws ClearingMetaServerValidationException, OtcMetaServerGetterNotFoundException { + if (objectsExtracted == null) { + objectsExtracted = new LinkedList<>(); + actionObjectsExtracted = new ConcurrentHashMap<>(); + objectsExtractedByClazz = new ConcurrentHashMap<>(); + objectsExtractedByDestination = new ConcurrentHashMap<>(); + objectElementByDestination = new ConcurrentHashMap<>(); + try { + Map objects = getObjects(); + log.info("Meta objects:\n{}", + objects.values() + .stream() + .map(ObjectElement::getName) + .collect(Collectors.joining(";", "[", "]"))); + for (String key : objects.keySet()) { + ObjectExtracted oe; + ObjectElement objectElement = objects.get(key); + if (objectElement.getSubscription() != null) { + objectElementByDestination.put(objectElement.getSubscription().destination, objectElement); + if (objectElement.getSubscriptionHistory() != null) { + objectElementByDestination.put(objectElement.getSubscriptionHistory().destination, objectElement); + } + } + try { + oe = getImplInstanceObjectExtracted(objectElement.getClazz(), objectElement.getFields()); + } catch (Throwable e) { + log.warn("META SERVER >>> Класс {} для {} не найден!", objects.get(key).getClazz(), key); + continue; + } + objectsExtracted.add(oe); + if (oe.getClassName() != null) { + ObjectExtracted previous = objectsExtractedByClazz.put(oe.getClassName(), oe); + if (previous != null) { + log.warn("!!! meta contains duplicate classes {}", oe.getClassName()); + } + } else + objectsExtractedByClazz.put(String.valueOf(classNameMock++), oe); + if (objectElement.getSubscription() != null && objectElement.getSubscription().destination != null) { + objectsExtractedByDestination.put(objectElement.getSubscription().destination, oe); + } + for (ActionElement actionElement : objectElement.getActions()) { + if (actionElement.getClazz() == null) { + continue; + } + + try { + oe = getImplInstanceObjectExtracted(actionElement.getClazz(), actionElement.getFields()); + if (actionElement.getArray() != null) { + oe.setArray(actionElement.getArray()); + } + } catch (Throwable e) { + log.warn("META SERVER >>> {}", e.getLocalizedMessage()); + continue; + } + actionObjectsExtracted.put(actionElement.getDestination(), oe); + } + } + } catch (Throwable e) { + throw new ClearingMetaServerValidationException(e.getLocalizedMessage()); + } + } + for (ObjectExtracted o : this.objectsExtracted) { + try { + if (!RfHelper.isAbstract(o.getClazz())) { + try { + Object instance = newInstance(o.getClassName()); + // создается успешно. + } catch (Throwable e) { + log.warn("META SERVER >>> Не удается создать класс {} !", o.getClassName()); + } + } + validateGetterForObject(o); + } catch (OtcMetaServerGetterNotFoundException e) { + throw e; + } catch (Throwable e) { + throw new ClearingMetaServerValidationException(e.getLocalizedMessage()); + } + } +// +// for (ObjectExtracted o : this.actionObjectsExtracted.values()) { +// try { +// if (!RfHelper.isAbstract(o.getClazz())) { +// try { +// Object instance = newInstance(o.getClassName()); +// // создается успешно. +// } catch (Throwable e) { +// log.warn("META SERVER ACTION >>> Не удается создать класс {} !", o.getClassName()); +// } +// } +// validateGetterForObject(o); +// } catch (OtcMetaServerGetterNotFoundException e) { +// throw e; +// } catch (Throwable e) { +// throw new ClearingMetaServerValidationException(e.getLocalizedMessage()); +// } +// } + } + + /** + * проверим наличие геттеров к полям + * + * @param o + * @throws ClassNotFoundException + */ + private void validateGetterForObject(ObjectExtracted o) throws ClassNotFoundException { + for (FieldExtracted field : o.getFields()) { + Class c = o.getClazz(); + for (String getterName : field.getGetterNames()) { + try { + Method m = RfHelper.searchGetter(c, getterName); + if (m == null) { + for (Class sub : RfHelper.getSubclasses(c)) { + m = RfHelper.searchGetter(sub, getterName); + if (m != null) + break; + } + if (m == null) { + throw new OtcMetaServerGetterNotFoundException(c, getterName); + } + } + c = RfHelper.getMetodReturnClazz(m); + } catch (OtcMetaServerGetterNotFoundException e) { + log.warn("META SERVER >>> Геттер {}.{} не найден!", o.getClassName(), getterName); + } + } + } + } + + public Object newInstance(String className, Object... args) throws Exception { + Class clazz = Class.forName(className); + if (args == null || args.length == 0) { + return clazz.newInstance(); + } + + List> argTypes = new ArrayList>(); + for (Object object : args) { + argTypes.add(object.getClass()); + } + Constructor explicitConstructor = clazz.getConstructor(argTypes.toArray(new Class[argTypes.size()])); + return explicitConstructor.newInstance(args); + } + + public Collection getObjectsExtracted() { + return objectsExtracted; + } + + public Map getActionObjectsExtracted() { + return actionObjectsExtracted; + } + + public Map getObjectsExtractedByClazz() { + return objectsExtractedByClazz; + } + + public Map getObjectElementByDestination() { + return objectElementByDestination; + } + + public Map getObjectsExtractedByDestination() { + return objectsExtractedByDestination; + } + + public Integer getPartSizeValueByDestination(String destination) { + ObjectElement objectElementByDestination = getObjectElementByDestination().get(destination); + Integer partSize = null; + if (objectElementByDestination == null) { + log.warn("Null objectElement for destination: {}", destination); + } else { + partSize = objectElementByDestination.getSubscription().getPartSize(); + } + return partSize; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java new file mode 100644 index 000000000..c554c5d29 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java @@ -0,0 +1,79 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.*; + +@SuppressWarnings({"DefaultAnnotationParam", "unused"}) +public class ObjectElement { + @JsonProperty(required = true) + private String name = null; + + @JsonProperty(value = "class", required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private String clazz = null; + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private String table = null; + + @JsonProperty(value = "fields", required = true) + private List fields = new LinkedList<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Map query = new LinkedHashMap<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Subscription subscription; + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Subscription subscriptionHistory; + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private List actions = new LinkedList<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private List> values = new LinkedList<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Map views = new HashMap<>(); + + public String getName() { + return name; + } + + public String getClazz() { + return clazz; + } + + public Map getQuery() { + return query; + } + + public Subscription getSubscription() { + return subscription; + } + + public List getActions() { + return actions; + } + + public List> getValues() { + return values; + } + + public List getFields() { + return fields; + } + + public Subscription getSubscriptionHistory() { + return subscriptionHistory; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectEnumElement.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectEnumElement.java new file mode 100644 index 000000000..6132e39bb --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectEnumElement.java @@ -0,0 +1,63 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.*; + +@SuppressWarnings({"DefaultAnnotationParam", "unused"}) +public class ObjectEnumElement { + @JsonProperty(required = true) + private String name = null; + + @JsonProperty(value = "class", required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private String clazz = null; + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private String table = null; + + @JsonProperty(value = "fields", required = true) + private List fields = new LinkedList<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Map query = new LinkedHashMap<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private List actions = new LinkedList<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private List> values = new LinkedList<>(); + + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private Map views = new HashMap<>(); + + public String getName() { + return name; + } + + public String getClazz() { + return clazz; + } + + public Map getQuery() { + return query; + } + + public List getActions() { + return actions; + } + + public List> getValues() { + return values; + } + + public List getFields() { + return fields; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java new file mode 100644 index 000000000..5f75b9de5 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java @@ -0,0 +1,61 @@ +package ru.spcex.clearing.backendapi.meta; + + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public abstract class ObjectExtracted { + private String className; + private Class clazz; + private List fields = new LinkedList<>(); + private Map fieldByCode = new ConcurrentHashMap<>(); + private boolean isArray = false; + + + public ObjectExtracted(String clazz, List actionFields) { + this.className = clazz; + try { + this.clazz = Class.forName(this.className); + } catch (ClassNotFoundException e) { + throw new ClearingMetaServerValidationException(String.format("Class not found [%s]", this.className)); + } + for (ActionField field : actionFields) { + if (field.getVirtual() != null && field.isVirtual()){ + continue; + } + FieldExtracted fe = getImplFieldExtracted(field); + fields.add(fe); + fieldByCode.put(field.getCode(), fe); + } + } + + public abstract FieldExtracted getImplFieldExtracted(ActionField field); + @Override + public String toString() { + return String.format("%s (fields=%d)", className, fields.size()); + } + + public String getClassName() { + return className; + } + + public Class getClazz() { + return clazz; + } + + public List getFields() { + return new ArrayList<>(fields); + } + + public Map getFieldByCode() { + return new HashMap<>(fieldByCode); + } + + public boolean isArray() { + return isArray; + } + + public void setArray(boolean array) { + isArray = array; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/OtcMetaServerGetterNotFoundException.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/OtcMetaServerGetterNotFoundException.java new file mode 100644 index 000000000..177f15db2 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/OtcMetaServerGetterNotFoundException.java @@ -0,0 +1,18 @@ +package ru.spcex.clearing.backendapi.meta; + + +import ru.clearing.classes.ConstSerializable; + +public class OtcMetaServerGetterNotFoundException extends RuntimeException { + private static final long serialVersionUID = ConstSerializable.serialVersionUID; + + public OtcMetaServerGetterNotFoundException(Class clazz, String getterName) { + super( + String.format( + "Method %s() not found for class %s and subclasses!", + getterName, clazz + ) + ); + } + +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/RfHelper.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/RfHelper.java new file mode 100644 index 000000000..099057f05 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/RfHelper.java @@ -0,0 +1,58 @@ +package ru.spcex.clearing.backendapi.meta; + +import org.reflections.Reflections; + +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class RfHelper { + + private static Map REFLECTION_CACHE = new HashMap<>(); + public static final String BUSINESS_OBJECT_REF = "BusinessObjectRef"; + public static final String OTC_CLASSES_PACKAGE = "com.moex.otc.classes"; + public static final String GETTER_NAME_PREFIX = "get"; + public static final String GETTER_NAME_ID = GETTER_NAME_PREFIX + "Id"; + + public static Method searchGetter(Class methodOwner, String name) { + for (Method m : methodOwner.getMethods()) { + if (m.getName().equals(name)) { + return m; + } + } + return null; + } + + public static Class[] getSubclasses(Class clazz) { + return getSubclasses(clazz, OTC_CLASSES_PACKAGE); + } + + public static Class[] getSubclasses(Class clazz, String packageName) { + Reflections reflections = REFLECTION_CACHE.computeIfAbsent(packageName, k -> new Reflections(packageName)); + Set> classes = reflections.getSubTypesOf(clazz); + return classes.toArray(new Class[]{}); + } + + public static boolean isAbstract(Class clazz) { + return Modifier.isAbstract(clazz.getModifiers()); + } + + public static Class getMetodReturnClazz(Method m) throws ClassNotFoundException { + Type t = m.getAnnotatedReturnType().getType(); + if (t instanceof ParameterizedType) { + Class raw = Class.forName(((ParameterizedType) t).getRawType().getTypeName()); + if (BUSINESS_OBJECT_REF.equals(raw.getSimpleName())) { + return Class.forName(((ParameterizedType) t).getActualTypeArguments()[0].getTypeName()); + } else if ("Set".equals(raw.getSimpleName())) { // множества пока не распаковываем + return Class.forName(raw.getName()); + } + } + return Class.forName(t.getTypeName()); + } + + +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/Subscription.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/Subscription.java new file mode 100644 index 000000000..53f364041 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/Subscription.java @@ -0,0 +1,38 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class Subscription { + @JsonProperty + public String destination; + + @JsonProperty + public boolean enabled; + + @JsonProperty(value = "partSize") + private Integer partSize; + + public String getDestination() { + return destination; + } + + public void setDestination(String destination) { + this.destination = destination; + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } + + public Integer getPartSize() { + return partSize; + } + + public void setPartSize(Integer partSize) { + this.partSize = partSize; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java index 1f58a2a48..c8caa0caa 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java @@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.service; import ru.spcex.platform.classes.base.SpcexObjectBase; import java.util.Collection; +import java.util.Map; import java.util.Optional; /** @@ -11,4 +12,5 @@ import java.util.Optional; public interface IStateLoader { Optional getById(Long id, String mapName, Class clazz); Collection getAll(String mapName, Class clazz); + Collection> getAllMetaTransform(String mapName, Class clazz); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java index 06667bc94..8d21ba817 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java @@ -2,6 +2,7 @@ package ru.spcex.clearing.backendapi.service.impl; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.imdg.api.Imdg; @@ -16,9 +17,11 @@ import java.util.concurrent.ConcurrentHashMap; public class StateLoaderImpl implements IStateLoader { private final Map> allImdgMaps; private final ImdgProvider imdgProvider; + private final GetResponseFactory responseFactory; @Autowired - public StateLoaderImpl(ImdgProvider imdgProvider) { + public StateLoaderImpl(ImdgProvider imdgProvider, GetResponseFactory responseFactory) { + this.responseFactory = responseFactory; this.allImdgMaps = new ConcurrentHashMap<>(); this.imdgProvider = imdgProvider; } @@ -35,6 +38,12 @@ public class StateLoaderImpl implements IStateLoader { return imdg.getAllValues(); } + @Override + public Collection> getAllMetaTransform(String mapName, Class clazz) { + Collection all = getAll(mapName, clazz); + return responseFactory.responseFromObjectCollection(all); + } + @SuppressWarnings("unchecked") private Imdg getImdg(String mapName, Class clazz) { return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz)); diff --git a/clearing-parent/backend-api/src/main/resources/meta/meta.server.xslt b/clearing-parent/backend-api/src/main/resources/meta/meta.server.xslt index a994995fc..7897340ca 100644 --- a/clearing-parent/backend-api/src/main/resources/meta/meta.server.xslt +++ b/clearing-parent/backend-api/src/main/resources/meta/meta.server.xslt @@ -47,19 +47,19 @@ , { - "": { + "code": "", "": "" , - }} + } , "": { - + "": "", "fields": [] @@ -70,7 +70,7 @@ , "": { - + "": "", "fields": [] @@ -148,8 +148,7 @@ , - {"": - { + {"code": "", "": @@ -164,7 +163,7 @@ , - }} + } diff --git a/clearing-parent/backend-api/src/main/resources/meta/meta.xml b/clearing-parent/backend-api/src/main/resources/meta/meta.xml index 2c066a2c6..7bc706510 100644 --- a/clearing-parent/backend-api/src/main/resources/meta/meta.xml +++ b/clearing-parent/backend-api/src/main/resources/meta/meta.xml @@ -1,6 +1,6 @@ - + @@ -242,7 +242,7 @@ - + @@ -254,14 +254,14 @@ - + - + @@ -274,7 +274,7 @@ - + @@ -288,7 +288,7 @@ - + @@ -312,7 +312,7 @@ - + @@ -336,7 +336,7 @@ - + @@ -369,7 +369,7 @@ - + @@ -380,7 +380,7 @@ - + @@ -394,9 +394,10 @@ + - + @@ -412,7 +413,7 @@ - + @@ -446,7 +447,7 @@ - + @@ -464,7 +465,7 @@ - + @@ -477,7 +478,7 @@ - + @@ -491,8 +492,24 @@ + + + + + + + + + + + + + + + + - + @@ -540,7 +557,7 @@ - + @@ -566,12 +583,12 @@ - + - + @@ -581,7 +598,7 @@ - + @@ -591,8 +608,15 @@ + + + + + + + - + @@ -635,18 +659,18 @@ - + - + - + @@ -659,19 +683,19 @@ - + - + - + @@ -682,7 +706,7 @@ - + @@ -692,7 +716,7 @@ - + @@ -702,7 +726,7 @@ - + @@ -714,7 +738,7 @@ - + @@ -725,7 +749,7 @@ - + @@ -768,7 +792,7 @@ - + @@ -794,7 +818,7 @@ - + @@ -811,7 +835,7 @@ - + @@ -827,32 +851,35 @@ - + - - - + + + - + - - - - - - + + + + + + + + - - - - - - - - - + + + + + + + + + + @@ -879,7 +906,7 @@ - + @@ -1018,7 +1045,7 @@ - + @@ -1064,7 +1091,7 @@ - + @@ -1151,7 +1178,7 @@ - + @@ -1160,7 +1187,7 @@ - + @@ -1178,7 +1205,7 @@ - + @@ -1197,7 +1224,7 @@ - + @@ -1248,7 +1275,7 @@ - + @@ -1300,7 +1327,7 @@ - +
@@ -1309,14 +1336,14 @@ - + - + @@ -1328,7 +1355,7 @@ - + @@ -1341,7 +1368,7 @@ - + @@ -1391,7 +1418,7 @@ - + @@ -1400,7 +1427,7 @@ - + @@ -1450,7 +1477,7 @@ - + @@ -1464,7 +1491,7 @@ - + @@ -1479,7 +1506,7 @@ - + @@ -1489,28 +1516,29 @@ - - + + + - - + + - + - - - - - - - - + + + + + + + + @@ -1527,13 +1555,21 @@ - + + + + + + + + + diff --git a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTest.java b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTest.java new file mode 100644 index 000000000..a408322a5 --- /dev/null +++ b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTest.java @@ -0,0 +1,66 @@ +package ru.spcex.clearing.backendapi.meta; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; + +import java.util.*; +import java.util.stream.Collectors; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = GetResponseFactoryTestConfiguration.class) +public class GetResponseFactoryTest { + private final MetaServer meta; + + @Autowired + public GetResponseFactoryTest(@Qualifier("metaJsonTest") MetaServer meta) { + this.meta = meta; + } + + @Test + public void testAllObjectsFields() throws ClassNotFoundException, InstantiationException, IllegalAccessException { + Collection allMetaObjects = meta.getObjects().values(); + Set> allMetaObjects2 = meta.getObjects().entrySet(); + Map> error = new HashMap<>(); + for (Map.Entry ent : allMetaObjects2) { + ObjectElement objectElement = ent.getValue(); + String className = objectElement.getClazz(); + Class classByName = null; + if (className == null) { + error.computeIfAbsent(ent.getKey(), v -> new ArrayList<>()).add(ent.getKey() + " no class property"); + continue; + } + try { + classByName = Class.forName(className); + } catch (ClassNotFoundException e) { + error.computeIfAbsent(ent.getKey(), v -> new ArrayList<>()).add(ent.getKey() + " cannot find class " + className); + continue; + } + Object object = classByName.newInstance(); + ObjectExtracted objectExtracted = meta.getObjectsExtractedByClazz().get(className); + for (FieldExtracted fieldExtracted : objectExtracted.getFields()) { + try { + fieldExtracted.extractValue(object); + } catch (Exception e) { + error.computeIfAbsent(ent.getKey(), v -> new ArrayList<>()).add( + "memberName " + fieldExtracted.getMemberName() + "; code " + fieldExtracted.getField().getCode() + "; field " + fieldExtracted.getField().getField() + ); + } + } + } + + String errorIfPresent = error + .entrySet() + .stream() + .map(entry -> entry.getKey() + ": " + entry.getValue() + .stream() + .collect(Collectors.joining(" |\n", "[", "]"))) + .collect(Collectors.joining("\n\n\n")); + Assertions.assertEquals(0, error.size(), errorIfPresent); + } + +} diff --git a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTestConfiguration.java b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTestConfiguration.java new file mode 100644 index 000000000..f3a989d58 --- /dev/null +++ b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTestConfiguration.java @@ -0,0 +1,46 @@ +package ru.spcex.clearing.backendapi.meta; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.io.PathResource; +import org.springframework.core.io.Resource; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +@Configuration +public class GetResponseFactoryTestConfiguration { + @Bean("metaJsonTestPath") + public Resource metaJsonPath() { + Path path = Paths.get("src", "main", "resources", "meta.json"); + return new PathResource(path); + } + +// @Value("file:${spring.config.location}/meta.json") +// private Resource meta; +// + @Bean("metaJsonTestRaw") + public String metaJsonRawString(@Qualifier("metaJsonTestPath") Resource meta) throws IOException { + if (!meta.isReadable()) throw new IllegalStateException("cannot read meta.json from meta " + meta.getFile()); + return Files.readString(meta.getFile().toPath()); + } +// + @Autowired + @Bean("metaJsonTest") + public MetaServer metaServer(@Qualifier("metaJsonTestRaw") String metaJson) throws JsonProcessingException { + ObjectMapper jsonObjectMapper = new ObjectMapper(); + jsonObjectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true); + jsonObjectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + MetaServer metaServer = jsonObjectMapper.readValue(metaJson, MetaServer.class); + metaServer.initAndValidate(); + return metaServer; + } +} diff --git a/clearing-parent/backend-api/src/test/ru/spcex/clearing/backendapi/controller/queue/config/IOperator.java b/clearing-parent/backend-api/src/test/ru/spcex/clearing/backendapi/controller/queue/config/IOperator.java index 065785269..9b6d845e9 100644 --- a/clearing-parent/backend-api/src/test/ru/spcex/clearing/backendapi/controller/queue/config/IOperator.java +++ b/clearing-parent/backend-api/src/test/ru/spcex/clearing/backendapi/controller/queue/config/IOperator.java @@ -6,6 +6,7 @@ import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.spcex.clearing.backendapi.service.impl.OperatorImpl; +import ru.spcex.clearing.backendapi.service.validation.ActionValidationProvider; import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; @Configuration @@ -17,8 +18,13 @@ public class IOperator { @Autowired @Bean - public OperatorImpl createIOperator(Producer kafka) { - return new OperatorImpl(kafka, hazelcastServiceTest); + public OperatorImpl createIOperator(Producer kafka, ActionValidationProvider validationProvider) { + return new OperatorImpl(kafka, hazelcastServiceTest, validationProvider); + } + + @Bean + public ActionValidationProvider validationForActions() { + return new ActionValidationProvider(hazelcastServiceTest); } }