diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/KafkaConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/KafkaConfig.java index 34973fffa..f0a86b0e6 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/KafkaConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/KafkaConfig.java @@ -1,18 +1,46 @@ package ru.spcex.clearing.account.config; import org.apache.kafka.clients.consumer.Consumer; +import org.apache.kafka.clients.producer.Producer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.spcex.clearing.account.config.settings.AccountServiceSettings; import ru.spcex.clearing.platform.messaging.config.KafkaConsumerFactory; +import ru.spcex.clearing.platform.messaging.config.KafkaProducerFactory; +import ru.spcex.clearing.platform.messaging.service.RequestInfo; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgId; +import ru.spcex.platform.imdg.api.ImdgProvider; @Configuration public class KafkaConfig { @Autowired @Bean - public Consumer createProducer(AccountServiceSettings settings) { - return KafkaConsumerFactory.consumer(settings.getKafka()); + public Consumer createConsumer(AccountServiceSettings settings) { + return KafkaConsumerFactory.consumer(settings.getKafkaConsumer()); + } + + @Autowired + @Bean + public Producer createProducer(AccountServiceSettings settings) { + return KafkaProducerFactory.producer(settings.getKafkaProducer()); + } + + @Autowired + @Bean + public KafkaSender kafkaSender(Producer kafkaProducer, ImdgProvider imdgProvider) { + ImdgId imdgIdGenerator = imdgProvider.getImdgIdGenerator(); + return KafkaSender + .setup() + .producer(kafkaProducer) + .idGenerator(imdgIdGenerator::nextId) + .imdgProvider(s -> { + Imdg imdg = imdgProvider.getImdg(s, RequestInfo.class); + return imdg::insert; + }) + .build(); } } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/settings/AccountServiceSettings.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/settings/AccountServiceSettings.java index f6f1166bb..1848ace41 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/settings/AccountServiceSettings.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/settings/AccountServiceSettings.java @@ -4,6 +4,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.PropertySource; import org.springframework.stereotype.Component; import ru.spcex.clearing.platform.messaging.config.element.KafkaConsumerSettings; +import ru.spcex.clearing.platform.messaging.config.element.KafkaProducerSettings; import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams; @Component @@ -11,7 +12,8 @@ import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams; @ConfigurationProperties("account-service") public class AccountServiceSettings { private HazelcastClientParams hazelcast; - private KafkaConsumerSettings kafka; + private KafkaConsumerSettings kafkaConsumer; + private KafkaProducerSettings kafkaProducer; public HazelcastClientParams getHazelcast() { return hazelcast; @@ -21,11 +23,19 @@ public class AccountServiceSettings { this.hazelcast = hazelcast; } - public KafkaConsumerSettings getKafka() { - return kafka; + public KafkaConsumerSettings getKafkaConsumer() { + return kafkaConsumer; } - public void setKafka(KafkaConsumerSettings kafka) { - this.kafka = kafka; + public void setKafkaConsumer(KafkaConsumerSettings kafkaConsumer) { + this.kafkaConsumer = kafkaConsumer; + } + + public KafkaProducerSettings getKafkaProducer() { + return kafkaProducer; + } + + public void setKafkaProducer(KafkaProducerSettings kafkaProducer) { + this.kafkaProducer = kafkaProducer; } } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java new file mode 100644 index 000000000..5a55e3809 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java @@ -0,0 +1,75 @@ +package ru.spcex.clearing.account.service; + +import org.apache.kafka.clients.consumer.Consumer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.Account; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.BaseRequest; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01Request; +import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01RequestPart; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.AccountSdf01ToStatementRequestPart; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest; +import ru.spcex.clearing.platform.messaging.service.QueueConsumer; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import java.util.ArrayList; +import java.util.List; + +@Service +public class AccountService extends QueueConsumer implements InitializingBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final Imdg accountMap; + private final KafkaSender kafkaSender; + + @Autowired + public AccountService(Consumer kafkaQueue, ImdgProvider imdgProvider, KafkaSender kafkaSender) { + super(kafkaQueue); + this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.kafkaSender = kafkaSender; + } + + @Override + public void afterPropertiesSet() { + callback(AccountSdf01Request.class) + .setConsumer(this::accountNew) + .forDestination(Consts.ACCOUNT_NEW, callbacks::put); + init(); + } + + private void accountNew(BaseRequest userRequest) { + AccountSdf01Request req = userRequest.getRequestPayload(); + log.debug("AccountSdf01Request received"); + List accountToStatement = new ArrayList<>(); + for (AccountSdf01RequestPart accountReq : req.getAccounts()) { + Account account = new Account(); + account.setAccount(accountReq.getAccount()); + //fixme account.setCompany(); + accountMap.insert(account); + AccountSdf01ToStatementRequestPart responsePart = responsePart(accountReq.getSdf01Id()); + accountToStatement.add(responsePart); + } + sendStatementRequestBack(accountToStatement); + log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size()); + } + + private AccountSdf01ToStatementRequestPart responsePart(Long sdf01Id) { + AccountSdf01ToStatementRequestPart responsePart = new AccountSdf01ToStatementRequestPart(); + responsePart.setSdf01Id(sdf01Id); + responsePart.setErrorCode(null); + responsePart.setErrorText(null); + return responsePart; + } + + private void sendStatementRequestBack(List results) { + StatementRequest request = new StatementRequest(); + request.setAccountCreationResults(results); + kafkaSender.sendRequestToQueue(Consts.STATEMENT_PROCESS, request); + } +} diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java index d8ec3a972..dcdd3693d 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/config/ValidationConfig.java @@ -4,6 +4,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; import ru.spcex.clearing.balance.validation.Sdf01ValidationRule; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -26,7 +27,9 @@ public class ValidationConfig { context.setValidatedObject(sDf01); BiConsumer> addImdg = (s, aClass) -> context.addImdg(s, imdgProvider.getImdg(s, aClass)); addImdg.accept(IMDGDistributedNames.Map_Account, Account.class); + addImdg.accept(IMDGDistributedNames.Map_Company, Company.class); return new ValidatorImpl<>(context, + Sdf01ValidationRule.CompanyPresent, Sdf01ValidationRule.AccountPresent, Sdf01ValidationRule.CurrencyCode, Sdf01ValidationRule.CurrentDateOnly, diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java index afc945838..4ef7a6482 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/service/StatementService.java @@ -10,35 +10,46 @@ import org.springframework.stereotype.Service; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; +import ru.clearing.classes.statics.data.sdf.SDf02; import ru.clearing.classes.statics.data.statement.Statement; import ru.spcex.clearing.balance.errors.BalanceError; import ru.spcex.clearing.balance.validation.ValidationStored; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.BaseRequest; import ru.spcex.clearing.platform.messaging.domain.Consts; -import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01Request; +import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01RequestPart; import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.enumeration.CurrencyCode; +import ru.spcex.platform.enumeration.InOutSDfType; +import ru.spcex.platform.enumeration.OperationStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.time.TimeUtil; import ru.spcex.platform.utils.validation.IValidator; -import java.util.Map; -import java.util.Optional; +import java.time.Instant; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.*; import java.util.function.Function; +import java.util.stream.Collectors; @Service public class StatementService extends QueueConsumer implements InitializingBean { private final Logger log = LoggerFactory.getLogger(getClass()); + private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy"); private final ImdgProvider imdgProvider; private final KafkaSender kafkaReqProducer; private final LoggingService errorLogger; private final Imdg sdf01Imdg; - private final Imdg companyImdg; - private final Imdg accountImdg; + private final Imdg sdf02Imdg; + private final Imdg accountBalanceImdg; private final Imdg statementImdg; private final Function sDf01Validator; @@ -48,9 +59,9 @@ public class StatementService extends QueueConsumer implements InitializingBean super(kafkaQueue); this.imdgProvider = imdgProvider; this.sdf01Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class); - this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); - this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);; this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class); + this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class); this.kafkaReqProducer = kafkaReqProducer; this.errorLogger = errorLogger; this.sDf01Validator = sDf01Validator; @@ -60,46 +71,170 @@ public class StatementService extends QueueConsumer implements InitializingBean public void afterPropertiesSet() throws Exception { callback(StatementRequest.class) .setConsumer(this::process) - .forDestination(Consts.DESTINATION_SDF02_NEW, callbacks::put); + .forDestination(Consts.STATEMENT_PROCESS, callbacks::put); init(); } private void process(BaseRequest systemRequest) { - StatementRequest sdfInfo = systemRequest.getRequestPayload(); - SDf01 sdf01 = sdf01Imdg.getSingleObjectByID(sdfInfo.getSdf01Id()); - Company company = companyImdg.getSingleObjectByFieldValues(Map.of("tradingCode", sdf01.getDeal())); - if (company == null) { - errorLogger.logError("sdf01.id={}", new EnumMessage(BalanceError.CompanyNotFound), sdfInfo.getSdf01Id()); - return; - } - IValidator validator = sDf01Validator.apply(sdf01); - Optional error = validator.tillFirstError(); - if (BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) { - kafkaReqProducer.sendRequestToQueue(Consts.ACCOUNT_NEW, createAccountRequest(sdf01.getAccount())); - log.info("account not found - send request for creation"); - return; - } - if (error.isPresent()) { - errorLogger.logError("sdf01.id={}", error.get(), sdf01.getId()); - return; - } - Statement statement = statementImdg.getSingleObjectByFieldValues(Map.of("account", sdf01.getAccount())); - - if (statement == null) { - createFlow(sdfInfo, validator.getStored(ValidationStored.Sdf01Account)); + StatementRequest statementRequest = systemRequest.getRequestPayload(); + Collection sdf01Group; + if (statementRequest.getAccountCreationResults().size() == 0) { + sdf01Group = sdf01Imdg.getCollectionObjectsByFieldValues(Map.of("generationId", statementRequest.getSdf01GroupId())); } else { -// updateFlow(statement); + sdf01Group = statementRequest.getAccountCreationResults() + .stream() + .filter(part -> part.getErrorCode() == null) //fixme эти случае должны попадать в ошибочный sdf02 + .map(part -> sdf01Imdg.getSingleObjectByID(part.getSdf01Id())) + .collect(Collectors.toList()); } + sdf01Group = sdf01Group + .stream() + .sorted(Comparator.comparing(SpcexObjectBase::getId)) + .collect(Collectors.toList()); + List accountRequests = new ArrayList<>(); + for (SDf01 sdf01 : sdf01Group) { + IValidator validator = sDf01Validator.apply(sdf01); + Optional error = validator.tillFirstError(); + Company company = validator.getStored(ValidationStored.Sdf01Company); + if (statementRequest.getAccountCreationResults().size() == 0 + && BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) { + //на данном шаге company существует -> getId ok + //формируем пакетный запрос на добавление account + //ответ придет в этот же метод, process + accountRequests.add(createAccountRequestPart(sdf01.getId(), sdf01.getAccount(), company.getId())); + log.info("account {} for sdf01.id={} not found - send request for creation", sdf01.getAccount(), sdf01.getId()); + } else if (BalanceError.AccountNotPresent.equals(error.map(EnumMessage::getSubject).orElse(null))) { + log.error("fatal error: resumed processing after generating accounts, but no account found for sdf01.id={}", sdf01.getId()); + continue; + } + if (error.isPresent()) { + errorLogger.logError("sdf01.id={}", error.get(), sdf01.getId()); + sdf02Imdg.insert(createErrorSdf02(sdf01, error.get())); + continue; + } + Statement statement = statementImdg.getSingleObjectByFieldValues(Map.of("account", sdf01.getAccount())); + if (statement == null) { + statement = createFlow(sdf01, + company, + validator.getStored(ValidationStored.Sdf01Account)); + } else { + updateFlow(statement, sdf01, + validator.getStored(ValidationStored.Sdf01Account)); + } + SDf02 sdf02New = createSuccessSdf02(sdf01); + sdf02Imdg.insert(sdf02New); + statement.setOutSDfId(sdf02New.getId()); + AccountBalance accountBalance = createSuccessAccountBalance(); + accountBalanceImdg.insert(accountBalance); + //fixme possible error from accountBalanceCreation -> other status + errorCode, errorText + statement.setStatus(OperationStatus.Executed.getKey()); + statementImdg.update(statement); + if (accountRequests.size() > 0) { + kafkaReqProducer.sendRequestToQueue(Consts.ACCOUNT_NEW, createAccountsRequest(sdf01.getGenerationId(), accountRequests)); + } + } } - private void createFlow(StatementRequest sdfInfo, Account storedObject) { - + private Statement createFlow(SDf01 sdf01, Company company, Account account) { + Statement statement = new Statement(); + statement.setAddresseeId(company.getId()); + statement.setSenderId(2L);// fixme справочник + statement.setCreated(Instant.now()); + statement.setClearingDate(TimeUtil.today()); + statement.setStatementTypeId(0L); //fixme справочник + statement.setAccountId(account.getId()); + statement.setAccount(0L); //fixme + statement.setInOutDirection(0L); //fixme + statement.setSettlementDate(TimeUtil.localDateToInstant(LocalDate.parse(sdf01.getDat(), datFormatter))); + statement.setAmount(null); //fixme sdf01.getRemainder() + statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey()); + statement.setStatus(OperationStatus.Pending.getKey()); + statement.setInSDfId(sdf01.getId()); + statement.setInOutSDfType(InOutSDfType.type1.getKey()); + statementImdg.insert(statement); + return statement; } - private AccountNewRequest createAccountRequest(String account) { - AccountNewRequest req = new AccountNewRequest(); + private void updateFlow(Statement statement, SDf01 sdf01, Account account) { + statement.setUpdated(Instant.now()); + statement.setStatementTypeId(0L); //fixme справочник + statement.setAccountId(account.getId()); + statement.setAccount(0L); //fixme + statement.setInOutDirection(0L); //fixme + statement.setSettlementDate(TimeUtil.localDateToInstant(LocalDate.parse(sdf01.getDat(), datFormatter))); + statement.setAmount(null); //fixme sdf01.getRemainder() + statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey()); + statementImdg.update(statement); + } + + private AccountSdf01RequestPart createAccountRequestPart(Long sdf01Id, String account, Long companyId) { + AccountSdf01RequestPart req = new AccountSdf01RequestPart(); req.setAccount(account); + req.setCompanyId(companyId); + req.setSdf01Id(sdf01Id); return req; } + + private AccountSdf01Request createAccountsRequest(Long sdf01GroupingId, List accountRequests) { + AccountSdf01Request r = new AccountSdf01Request(); + r.setGroupingSdf01Id(sdf01GroupingId); + r.setAccounts(accountRequests); + return r; + } + + private SDf02 createErrorSdf02(SDf01 sdf01, EnumMessage error) { + SDf02 sDf02 = new SDf02(); + sDf02.setCurr_code(sdf01.getCurr_code()); + sDf02.setAccount(sdf01.getAccount()); + sDf02.setRemainder(sdf01.getRemainder()); + sDf02.setDeal(sdf01.getDeal()); + sDf02.setAcc_code(sdf01.getAcc_code()); + sDf02.setDat(sdf01.getDat()); + sDf02.setMarket(sdf01.getMarket()); + sDf02.setAcc_name(sdf01.getAcc_name()); + sDf02.setAcc_type(sdf01.getAcc_type()); + sDf02.setSumengage(sdf01.getSumengage()); + sDf02.setSumunblock(sdf01.getSumunblock()); + sDf02.setFile_type(sdf01.getFile_type()); + sDf02.setInSDf01Id(sdf01.getId()); + String errorId = error.getSubject().getId().toString(); + sDf02.setResult(errorId.substring(errorId.length() - 3)); + return sDf02; + } + + private SDf02 createSuccessSdf02(SDf01 sdf01) { + SDf02 sDf02 = new SDf02(); + sDf02.setCurr_code(sdf01.getCurr_code()); + sDf02.setAccount(sdf01.getAccount()); + sDf02.setRemainder(sdf01.getRemainder()); + sDf02.setDeal(sdf01.getDeal()); + sDf02.setAcc_code(sdf01.getAcc_code()); + sDf02.setDat(sdf01.getDat()); + sDf02.setMarket(sdf01.getMarket()); + sDf02.setAcc_name(sdf01.getAcc_name()); + sDf02.setAcc_type(sdf01.getAcc_type()); + sDf02.setSumengage(sdf01.getSumengage()); + sDf02.setSumunblock(sdf01.getSumunblock()); + sDf02.setFile_type(sdf01.getFile_type()); + sDf02.setInSDf01Id(sdf01.getId()); + sDf02.setResult("OK!"); + return sDf02; + } + + private AccountBalance createSuccessAccountBalance() { + return new AccountBalance(); + } + + private static class AccountBalance extends SpcexObjectBase { + private String message = "AccountBalance"; + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + } } diff --git a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java index b5ed4842f..78ebb937d 100644 --- a/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java +++ b/clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java @@ -1,6 +1,7 @@ package ru.spcex.clearing.balance.validation; import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.sdf.SDf01; import ru.spcex.clearing.balance.config.ImdgValidationContext; import ru.spcex.clearing.balance.errors.BalanceError; @@ -11,10 +12,24 @@ import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.validation.IValidationRule; import java.time.LocalDate; +import java.time.format.DateTimeFormatter; import java.util.Map; import java.util.Optional; public enum Sdf01ValidationRule implements IValidationRule> { + CompanyPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + SDf01 sdf01 = context.getValidatedObject(); + Imdg companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class); + Company company = companyImdg.getSingleObjectByFieldValues(Map.of("tradingCode", sdf01.getDeal())); + if (company == null) { + return of( BalanceError.CompanyNotFound); + } + context.storeObject(ValidationStored.Sdf01Company, company); + return empty(); + } + }, AccountPresent() { @Override public Optional validate(ImdgValidationContext context) { @@ -44,7 +59,7 @@ public enum Sdf01ValidationRule implements IValidationRule validate(ImdgValidationContext context) { SDf01 sdf01 = context.getValidatedObject(); //fixme string format??? - if (!LocalDate.now().toString().equals(sdf01.getDat())) { + if (!LocalDate.now().equals(LocalDate.parse(sdf01.getDat(), datFormatter))) { return of(BalanceError.CurrentDateOnly); } return empty(); @@ -70,6 +85,8 @@ public enum Sdf01ValidationRule implements IValidationRule accounts; + + public List getAccounts() { + return accounts; + } + + public void setAccounts(List accounts) { + this.accounts = accounts; + } + + public Long getGroupingSdf01Id() { + return groupingSdf01Id; + } + + public void setGroupingSdf01Id(Long groupingSdf01Id) { + this.groupingSdf01Id = groupingSdf01Id; + } +} diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/account/sdf01/AccountSdf01RequestPart.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/account/sdf01/AccountSdf01RequestPart.java new file mode 100644 index 000000000..a48429623 --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/account/sdf01/AccountSdf01RequestPart.java @@ -0,0 +1,36 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class AccountSdf01RequestPart { + @JsonProperty + private Long sdf01Id; + @JsonProperty + private String account; + @JsonProperty + private Long companyId; + + public Long getSdf01Id() { + return sdf01Id; + } + + public void setSdf01Id(Long sdf01Id) { + this.sdf01Id = sdf01Id; + } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } + + public Long getCompanyId() { + return companyId; + } + + public void setCompanyId(Long companyId) { + this.companyId = companyId; + } +} diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/AccountSdf01ToStatementRequestPart.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/AccountSdf01ToStatementRequestPart.java new file mode 100644 index 000000000..4921c9d2e --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/AccountSdf01ToStatementRequestPart.java @@ -0,0 +1,36 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.balance; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class AccountSdf01ToStatementRequestPart { + @JsonProperty + private Long sdf01Id; + @JsonProperty + private Long errorCode; + @JsonProperty + private String errorText; + + public Long getSdf01Id() { + return sdf01Id; + } + + public void setSdf01Id(Long sdf01Id) { + this.sdf01Id = sdf01Id; + } + + public Long getErrorCode() { + return errorCode; + } + + public void setErrorCode(Long errorCode) { + this.errorCode = errorCode; + } + + public String getErrorText() { + return errorText; + } + + public void setErrorText(String errorText) { + this.errorText = errorText; + } +} diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequest.java index d1a98147a..06193017e 100644 --- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequest.java +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequest.java @@ -2,15 +2,40 @@ package ru.spcex.clearing.platform.messaging.domain.cud.balance; import com.fasterxml.jackson.annotation.JsonProperty; +import java.util.ArrayList; +import java.util.List; + public class StatementRequest { @JsonProperty - private Long sdf01Id; + private Long sdf01GroupId; + //------------------- + //from accountBalance creation + @JsonProperty + List accountCreationResults = new ArrayList<>(); + //from sDf02 creation - public Long getSdf01Id() { - return sdf01Id; +// public StatementRequestType getType() { +// if (errorCode != null || errorText != null || status != null) { +// return StatementRequestType.accountBalanceResponse; +// } else if (inOutSDfType != null) { +// return StatementRequestType.sdf02Response; +// } else return StatementRequestType.create; +// return type; +// } + + public Long getSdf01GroupId() { + return sdf01GroupId; } - public void setSdf01Id(Long sdf01Id) { - this.sdf01Id = sdf01Id; + public void setSdf01GroupId(Long sdf01GroupId) { + this.sdf01GroupId = sdf01GroupId; + } + + public List getAccountCreationResults() { + return accountCreationResults; + } + + public void setAccountCreationResults(List accountCreationResults) { + this.accountCreationResults = accountCreationResults; } } \ No newline at end of file diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequestType.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequestType.java new file mode 100644 index 000000000..02434916b --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/balance/StatementRequestType.java @@ -0,0 +1,6 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.balance; + +public enum StatementRequestType { + create, accountBalanceResponse, sdf02Response, + batch +}