diff --git a/clearing-parent/pom.xml b/clearing-parent/pom.xml index 5b30fef4f..4dac9febc 100644 --- a/clearing-parent/pom.xml +++ b/clearing-parent/pom.xml @@ -44,6 +44,7 @@ gateway-api imdg-hist xml-importer + xml-exporter diff --git a/clearing-parent/xml-exporter/pom.xml b/clearing-parent/xml-exporter/pom.xml new file mode 100644 index 000000000..0e5d3192c --- /dev/null +++ b/clearing-parent/xml-exporter/pom.xml @@ -0,0 +1,123 @@ + + + 4.0.0 + + xml-exporter + xml-exporter + XML exporter for XML files + SPCEX-3.11.0.0 + + + clearing-parent + ru.spcex.clearing + SPCEX-3.11.0.0 + + + + + + org.springframework.boot + spring-boot-starter + + + org.springframework.boot + spring-boot-autoconfigure + + + org.springframework.integration + spring-integration-sftp + + + + + com.fasterxml.jackson.core + jackson-core + + + com.fasterxml.jackson.core + jackson-databind + + + com.fasterxml.jackson.dataformat + jackson-dataformat-xml + + + com.fasterxml.woodstox + woodstox-core + 6.6.2 + + + com.fasterxml.jackson.datatype + jackson-datatype-jsr310 + + + + + ru.spcex.platform + platform-imdg-api-hazelcast-impl + + + ru.spcex.platform + platform-messaging + + + ru.spcex.clearing + classes + + + ru.spcex.clearing + classes + + + + + net.logstash.logback + logstash-logback-encoder + 7.0.1 + + + + + org.springframework.boot + spring-boot-starter-test + test + + + ru.spcex.clearing + test-clearing + test + + + + + + + + src/main/resources + + application.properties + + false + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + repackage + + + + + ${project.artifactId} + + + + + + \ No newline at end of file diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/XMLExporterApplication.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/XMLExporterApplication.java new file mode 100644 index 000000000..fdfbfcd37 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/XMLExporterApplication.java @@ -0,0 +1,18 @@ +package ru.spcex.clearing.xml.exporter; + +import org.slf4j.LoggerFactory; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.builder.SpringApplicationBuilder; + +@SpringBootApplication +public class XMLExporterApplication { + public static void main(String[] args) { + try { + SpringApplicationBuilder builder = new SpringApplicationBuilder(XMLExporterApplication.class); + builder.run(args); + } catch (Throwable e) { + LoggerFactory.getLogger(XMLExporterApplication.class).error("XML-Loader start failed: {} -> {}", e.getClass().getSimpleName(), e.getMessage()); + System.exit(-1); + } + } +} \ No newline at end of file diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/ImdgConfig.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/ImdgConfig.java new file mode 100644 index 000000000..fd1358110 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/ImdgConfig.java @@ -0,0 +1,57 @@ +package ru.spcex.clearing.xml.exporter.config; + +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; +import ru.spcex.clearing.xml.exporter.config.settings.ExportXMLServiceSettings; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams; +import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; + +@Configuration +public class ImdgConfig { + @Bean("taskExecutorHazelcastClientInitializer") + public ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer() { + return createThreadPoolTaskExecutor(1, true); + } + + @Bean("taskExecutorIdGeneratorAwaiter") + public ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter() { + return createThreadPoolTaskExecutor(1, false); + } + + @Bean("imdgProvider") + public ImdgProvider imdgProvider(@Qualifier("taskExecutorHazelcastClientInitializer") ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer, + @Qualifier("taskExecutorIdGeneratorAwaiter") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter, + ExportXMLServiceSettings settings) { + HazelcastClientParams params = new HazelcastClientParams(); + params.setClusterMembers(settings.getHazelcast().getClusterMembers()); + params.setLogin(settings.getHazelcast().getLogin()); + params.setPassword(settings.getHazelcast().getPassword()); + return new HazelcastService(taskExecutorHazelcastClientInitializer, taskExecutorIdGeneratorAwaiter, params); + } + + @Bean("executor") + public ThreadPoolTaskExecutor executor(ExportXMLServiceSettings settings) { + ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); + executor.setMaxPoolSize(settings.getCommon().getThreadsCount()); + executor.setCorePoolSize(settings.getCommon().getThreadsCount()); + executor.setThreadNamePrefix("xml-exporter-"); + executor.setWaitForTasksToCompleteOnShutdown(true); + executor.setAwaitTerminationSeconds(300); + executor.initialize(); + return executor; + } + + private static ThreadPoolTaskExecutor createThreadPoolTaskExecutor(int maxPoolSz, boolean waitForCompletion) { + ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor(); + if (maxPoolSz > 2) { + pool.setKeepAliveSeconds(60); + pool.setAllowCoreThreadTimeOut(true); + } + pool.setCorePoolSize(maxPoolSz); + pool.setWaitForTasksToCompleteOnShutdown(waitForCompletion); + return pool; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/KafkaConfig.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/KafkaConfig.java new file mode 100644 index 000000000..2a8b5ad61 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/KafkaConfig.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.xml.exporter.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.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Scope; +import ru.spcex.clearing.platform.messaging.config.KafkaConsumerFactory; +import ru.spcex.clearing.platform.messaging.config.KafkaProducerFactory; +import ru.spcex.clearing.xml.exporter.config.settings.ExportXMLServiceSettings; + +@Configuration +public class KafkaConfig { + @Autowired + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + @Bean + public Consumer createConsumer(ExportXMLServiceSettings settings) { + return KafkaConsumerFactory.consumer(settings.getKafkaConsumer()); + } + + @Autowired + @Bean + public Producer createProducer(ExportXMLServiceSettings settings) { + if (settings.getKafkaProducer() != null) { + return KafkaProducerFactory.producer(settings.getKafkaProducer()); + } else + return null; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/KafkaSenderConfig.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/KafkaSenderConfig.java new file mode 100644 index 000000000..e2472ed5b --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/KafkaSenderConfig.java @@ -0,0 +1,63 @@ +package ru.spcex.clearing.xml.exporter.config; + +import java.util.function.Supplier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.kafka.core.KafkaTemplate; +import org.springframework.kafka.core.ProducerFactory; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.config.KafkaProducerFactory; +import ru.spcex.clearing.platform.messaging.config.element.KafkaProducerSettings; +import ru.spcex.clearing.platform.messaging.service.RequestInfo; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.xml.exporter.config.settings.ExportXMLServiceSettings; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgId; +import ru.spcex.platform.imdg.api.ImdgProvider; + +@Configuration +public class KafkaSenderConfig { + Logger log = LoggerFactory.getLogger(getClass()); + + private final ImdgProvider imdgProvider; + + @Autowired + public KafkaSenderConfig(ImdgProvider imdgProvider) { + this.imdgProvider = imdgProvider; + } + + @Bean + public ProducerFactory pf(ExportXMLServiceSettings settings) { + if (settings.getKafkaProducer() == null) { + return null; + } + KafkaProducerSettings kafkaSettings = settings.getKafkaProducer(); + return KafkaProducerFactory.producerFactory(kafkaSettings); + } + + @Bean("kafkaTemplate") + public KafkaTemplate kafkaTemplate(ProducerFactory pf) { + if (pf == null) { + return null; + } + return new KafkaTemplate<>(pf); + } + + @Bean + public Supplier kafkaSenderSupplier(KafkaTemplate kafkaTemplate, + ImdgProvider imdgProvider) { + ImdgId imdgIdGenerator = imdgProvider.getImdgIdGenerator(); + return () -> KafkaSender + .setup() + .setKafkaTemplate(kafkaTemplate) + .idGenerator(imdgIdGenerator::nextId) + .imdgProvider(s -> { + Imdg imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_RequestInfo, RequestInfo.class); + return imdg::insert; + }) + .build(); + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/SFTPConfig.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/SFTPConfig.java new file mode 100644 index 000000000..04fe0a895 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/SFTPConfig.java @@ -0,0 +1,93 @@ +package ru.spcex.clearing.xml.exporter.config; + +import static org.springframework.integration.file.remote.gateway.AbstractRemoteFileOutboundGateway.Command.LS; + +import com.jcraft.jsch.ChannelSftp; +import java.io.File; +import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.expression.ExpressionParser; +import org.springframework.expression.spel.standard.SpelExpressionParser; +import org.springframework.integration.annotation.Gateway; +import org.springframework.integration.annotation.MessagingGateway; +import org.springframework.integration.annotation.ServiceActivator; +import org.springframework.integration.channel.DirectChannel; +import org.springframework.integration.file.remote.gateway.AbstractRemoteFileOutboundGateway; +import org.springframework.integration.file.remote.session.CachingSessionFactory; +import org.springframework.integration.file.remote.session.SessionFactory; +import org.springframework.integration.sftp.gateway.SftpOutboundGateway; +import org.springframework.integration.sftp.outbound.SftpMessageHandler; +import org.springframework.integration.sftp.session.DefaultSftpSessionFactory; +import org.springframework.integration.sftp.session.SftpFileInfo; +import org.springframework.messaging.MessageChannel; +import org.springframework.messaging.MessageHandler; +import org.springframework.messaging.handler.annotation.Header; +import org.springframework.messaging.handler.annotation.Payload; +import ru.spcex.clearing.xml.exporter.config.settings.ExportXMLServiceSettings; + +@Configuration +public class SFTPConfig { + protected Logger log = LoggerFactory.getLogger(getClass()); + protected static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser(); + + @Bean + public SessionFactory sftpSessionFactory(ExportXMLServiceSettings settings) { + DefaultSftpSessionFactory factory = new DefaultSftpSessionFactory(true); + factory.setHost(settings.getStore().getServerIp()); + factory.setPort(settings.getStore().getServerPort()); + factory.setUser(settings.getStore().getUser()); + factory.setPassword(settings.getStore().getPassword()); + factory.setAllowUnknownKeys(true); + return new CachingSessionFactory<>(factory); + } + + @Bean + @ServiceActivator(inputChannel = "toSftpChannel") + public MessageHandler handler(SessionFactory sessionFactory) { + SftpMessageHandler handler = new SftpMessageHandler(sessionFactory); + handler.setRemoteDirectoryExpression(EXPRESSION_PARSER.parseExpression("headers['path']")); + handler.setAutoCreateDirectory(true); + handler.setFileNameGenerator(message -> { + if (message.getPayload() instanceof File) { + return ((File) message.getPayload()).getName(); + }else { + throw new IllegalArgumentException("File must expected as payload."); + } + }); + return handler; + } + + @MessagingGateway + public interface XmlGateway { + @Gateway(requestChannel = "toSftpChannel") + void sendToSftp(@Payload File file, @Header("path") String path); + + @Gateway(requestChannel = "listSftpChannel") + List listFiles(@Payload String dir); + } + + @Bean + public MessageChannel listSftpChannel(SessionFactory sessionFactory) { + DirectChannel dc = new DirectChannel(); + dc.subscribe(handlerList(sessionFactory)); + return dc; + } + + @Bean + public MessageChannel toSftpChannel(SessionFactory sessionFactory) { + DirectChannel dc = new DirectChannel(); + dc.subscribe(handler(sessionFactory)); + return dc; + } + + @Bean + @ServiceActivator(inputChannel = "listSftpChannel") + public MessageHandler handlerList(SessionFactory sessionFactory) { + SftpOutboundGateway sftpOutboundGateway = new SftpOutboundGateway(sessionFactory, LS.getCommand(), "payload"); + sftpOutboundGateway.setOption(AbstractRemoteFileOutboundGateway.Option.RECURSIVE); + return sftpOutboundGateway; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/XMLExporterConfig.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/XMLExporterConfig.java new file mode 100644 index 000000000..f487d06ae --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/XMLExporterConfig.java @@ -0,0 +1,83 @@ +package ru.spcex.clearing.xml.exporter.config; + +import com.ctc.wstx.stax.WstxInputFactory; +import com.ctc.wstx.stax.WstxOutputFactory; +import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.dataformat.xml.XmlFactory; +import com.fasterxml.jackson.dataformat.xml.XmlMapper; +import com.fasterxml.jackson.dataformat.xml.ser.ToXmlGenerator; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLOutputFactory; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.context.ApplicationContext; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import ru.spcex.clearing.xml.exporter.logic.data.enums.Table; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF02ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF03ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF05ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF07ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF51ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF53ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF54ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.DF56ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.ObjectTag; +import ru.spcex.clearing.xml.exporter.logic.stages.ExportFromHazelcast; +import ru.spcex.clearing.xml.exporter.logic.stages.Journal; +import ru.spcex.clearing.xml.exporter.logic.stages.PrepareXMLFile; +import ru.spcex.clearing.xml.exporter.logic.stages.Stage; +import ru.spcex.platform.classes.base.SpcexObjectBase; + +@Configuration +@EnableConfigurationProperties +@ComponentScan(basePackages = {"ru.spcex.clearing.xml.exporter"}) +public class XMLExporterConfig { + @Bean("pipeline") + public List pipeline(ApplicationContext context) { + List pipeline = new LinkedList<>(); + + pipeline.add(context.getBean(PrepareXMLFile.class)); + pipeline.add(context.getBean(ExportFromHazelcast.class)); + pipeline.add(context.getBean(Journal.class)); + + return pipeline; + } + + @Bean("mapOfTable") + public Map> getMapOfTables() { + Map> map = new HashMap<>(); + map.put(Table.S_DF02, new DF02ObjectTag()); + map.put(Table.S_DF03, new DF03ObjectTag()); + map.put(Table.S_DF05, new DF05ObjectTag()); + map.put(Table.S_DF07, new DF07ObjectTag()); + map.put(Table.S_DF51, new DF51ObjectTag()); + map.put(Table.S_DF53, new DF53ObjectTag()); + map.put(Table.S_DF54, new DF54ObjectTag()); + map.put(Table.S_DF56, new DF56ObjectTag()); + return map; + } + + @Bean("xmlMapper") + public XmlMapper xmlMapper() { + XMLInputFactory inputFactory = new WstxInputFactory(); + XMLOutputFactory outputFactory = new WstxOutputFactory(); + + XmlFactory xmlFactory = XmlFactory.builder() + .xmlInputFactory(inputFactory) + .xmlOutputFactory(outputFactory) + .build(); + + XmlMapper xmlMapper = new XmlMapper(xmlFactory); + xmlMapper.registerModule(new JavaTimeModule()); + xmlMapper.configure(ToXmlGenerator.Feature.WRITE_XML_DECLARATION, true); + xmlMapper.configure(SerializationFeature.INDENT_OUTPUT, true); + + return xmlMapper; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Common.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Common.java new file mode 100644 index 000000000..50f816353 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Common.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.xml.exporter.config.settings; + +public class Common { + private String encoding; + private int insertBatchSize; + private int threadsCount; + + public String getEncoding() { + return encoding; + } + + public void setEncoding(String encoding) { + this.encoding = encoding; + } + + public int getInsertBatchSize() { + return insertBatchSize; + } + + public void setInsertBatchSize(int insertBatchSize) { + this.insertBatchSize = insertBatchSize; + } + + public int getThreadsCount() { + return threadsCount; + } + + public void setThreadsCount(int threadsCount) { + this.threadsCount = threadsCount; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Cron.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Cron.java new file mode 100644 index 000000000..cc306ffc6 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Cron.java @@ -0,0 +1,13 @@ +package ru.spcex.clearing.xml.exporter.config.settings; + +public class Cron { + private String checkSrcDirCron; + + public String getCheckSrcDirCron() { + return checkSrcDirCron; + } + + public void setCheckSrcDirCron(String checkSrcDirCron) { + this.checkSrcDirCron = checkSrcDirCron; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/ExportXMLServiceSettings.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/ExportXMLServiceSettings.java new file mode 100644 index 000000000..52ac3bca9 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/ExportXMLServiceSettings.java @@ -0,0 +1,68 @@ +package ru.spcex.clearing.xml.exporter.config.settings; + +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 +@PropertySource("file:${spring.config.location}/application.properties") +@ConfigurationProperties("export-xml-service") +public class ExportXMLServiceSettings { + private HazelcastClientParams hazelcast; + private KafkaConsumerSettings kafkaConsumer; + private KafkaProducerSettings kafkaProducer; + private Common common; + private Store store; + private Cron cron; + + public HazelcastClientParams getHazelcast() { + return hazelcast; + } + + public void setHazelcast(HazelcastClientParams hazelcast) { + this.hazelcast = hazelcast; + } + + public KafkaConsumerSettings getKafkaConsumer() { + return kafkaConsumer; + } + + public void setKafkaConsumer(KafkaConsumerSettings kafkaConsumer) { + this.kafkaConsumer = kafkaConsumer; + } + + public Common getCommon() { + return common; + } + + public void setCommon(Common common) { + this.common = common; + } + + public Store getStore() { + return store; + } + + public void setStore(Store store) { + this.store = store; + } + + public Cron getCron() { + return cron; + } + + public void setCron(Cron cron) { + this.cron = cron; + } + + public KafkaProducerSettings getKafkaProducer() { + return kafkaProducer; + } + + public void setKafkaProducer(KafkaProducerSettings kafkaProducer) { + this.kafkaProducer = kafkaProducer; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Store.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Store.java new file mode 100644 index 000000000..c77383990 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/config/settings/Store.java @@ -0,0 +1,69 @@ +package ru.spcex.clearing.xml.exporter.config.settings; + +import java.util.Map; + +public class Store { + private String outDir; + private String localTempDir; + private String user; + private String password; + private String serverIp; + private int serverPort; + private Map outPayValDir; + + public String getUser() { + return user; + } + + public void setUser(String user) { + this.user = user; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public String getServerIp() { + return serverIp; + } + + public void setServerIp(String serverIp) { + this.serverIp = serverIp; + } + + public int getServerPort() { + return serverPort; + } + + public void setServerPort(int serverPort) { + this.serverPort = serverPort; + } + + public String getOutDir() { + return outDir; + } + + public void setOutDir(String outDir) { + this.outDir = outDir; + } + + public String getLocalTempDir() { + return localTempDir; + } + + public void setLocalTempDir(String localTempDir) { + this.localTempDir = localTempDir; + } + + public Map getOutPayValDir() { + return outPayValDir; + } + + public void setOutPayValDir(Map outPayValDir) { + this.outPayValDir = outPayValDir; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/exceptions/ConfigException.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/exceptions/ConfigException.java new file mode 100644 index 000000000..8c100ef35 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/exceptions/ConfigException.java @@ -0,0 +1,6 @@ +package ru.spcex.clearing.xml.exporter.exceptions; + +public class ConfigException extends RuntimeException { + public ConfigException(String msg) { super(msg); } + public ConfigException(String msg, Throwable cause) { super(msg, cause); } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/Processor.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/Processor.java new file mode 100644 index 000000000..a012fef04 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/Processor.java @@ -0,0 +1,40 @@ +package ru.spcex.clearing.xml.exporter.logic; + +import java.util.Arrays; +import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; +import ru.spcex.clearing.xml.exporter.logic.data.enums.StageResult; +import ru.spcex.clearing.xml.exporter.logic.stages.Stage; + +@Component("processor") +public class Processor { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final List pipeline; + + public Processor(@Qualifier("pipeline") List pipeline) { + this.pipeline = pipeline; + } + + public void process(ResultContainer task) { + log.info("uuid {}. Task started", task.getUuid()); + StageResult result = null; + long startMills = System.currentTimeMillis(); + for (Stage currStage : pipeline) { + if (result != null + && Arrays.asList(StageResult.ERROR, StageResult.COMPLETE).contains(result) + && currStage.skipCompleted()) continue; + log.info("uuid {}. Stage: {}", task.getUuid(), currStage.getClass().getSimpleName()); + result = currStage.process(task); + task.setLastStageResult(result); + } + long endMills = System.currentTimeMillis(); + log.info("uuid {}. Task completed, result: {}, time working: {} ms", + task.getUuid(), + result, + endMills - startMills); + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/ResultContainer.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/ResultContainer.java new file mode 100644 index 000000000..8b5446f2f --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/ResultContainer.java @@ -0,0 +1,91 @@ +package ru.spcex.clearing.xml.exporter.logic.data; + +import java.io.File; +import java.time.LocalDateTime; +import java.util.UUID; +import ru.spcex.clearing.xml.exporter.logic.data.enums.StageResult; +import ru.spcex.clearing.xml.exporter.logic.data.enums.Table; + +public class ResultContainer { + private String sourceName; // имя инициатора (файла) + private UUID uuid; + private Table tableForExport; + private File fileForExport; + private Long groupId; + private StageResult lastStageResult; + private LocalDateTime registrationDateTime; + private String memberCode; + + protected ResultContainer() {} + + public static ResultContainer createNewTask(Table tableForExport) { + ResultContainer container = new ResultContainer(); + container.tableForExport = tableForExport; + container.uuid = UUID.randomUUID(); + return container; + } + + public Table getTableForExport() { + return tableForExport; + } + + public void setTableForExport(Table tableForExport) { + this.tableForExport = tableForExport; + } + + public File getFileForExport() { + return fileForExport; + } + + public void setFileForExport(File fileForExport) { + this.fileForExport = fileForExport; + } + + public UUID getUuid() { + return uuid; + } + + public void setUuid(UUID uuid) { + this.uuid = uuid; + } + + public Long getGroupId() { + return groupId; + } + + public void setGroupId(Long groupId) { + this.groupId = groupId; + } + + public String getSourceName() { + return sourceName; + } + + public void setSourceName(String sourceName) { + this.sourceName = sourceName; + } + + public StageResult getLastStageResult() { + return lastStageResult; + } + + public void setLastStageResult(StageResult lastStageResult) { + this.lastStageResult = lastStageResult; + } + + public LocalDateTime getRegistrationDateTime() { + return registrationDateTime; + } + + public void setRegistrationDateTime(LocalDateTime registrationDateTime) { + this.registrationDateTime = registrationDateTime; + } + + public String getMemberCode() { + return memberCode; + } + + public void setMemberCode(String memberCode) { + this.memberCode = memberCode; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/FilenameTemplate.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/FilenameTemplate.java new file mode 100644 index 000000000..58f406480 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/FilenameTemplate.java @@ -0,0 +1,130 @@ +package ru.spcex.clearing.xml.exporter.logic.data.enums; + +import static ru.spcex.clearing.xml.exporter.logic.stages.PrepareXMLFile.SECTION; +import static ru.spcex.clearing.xml.exporter.logic.stages.PrepareXMLFile.outDir; + +import java.io.File; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.List; +import java.util.Locale; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.integration.sftp.session.SftpFileInfo; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; + +public enum FilenameTemplate { + df_section_dateTime { + @Override + public String getFileName(ResultContainer resultContainer, List files) { + return appendSection(resultContainer) + .append(dateTime(resultContainer)) + .append(".XML").toString(); + } + }, + df_section_dateTime_counter { + @Override + public String getFileName(ResultContainer resultContainer, List files) { + return appendSection(resultContainer) + .append(dateTime(resultContainer)) + .append(counter(resultContainer, files)) + .append(".XML").toString(); + } + }, + df_section_sameName { + @Override + public String getFileName(ResultContainer resultContainer, List files) { + if (resultContainer.getSourceName() == null) { + LoggerFactory.getLogger(getClass()).warn("{} groupId={}, SourceName no set. Do default name as df_section_dateTime_counter.", resultContainer.getTableForExport(), resultContainer.getGroupId()); + return df_section_dateTime_counter.getFileName(resultContainer, files); + } + String name = resultContainer.getSourceName(); + int i = name.indexOf("_"); + if (i < 0) throw new IllegalArgumentException("Unexpected source name (symbol _ not found): " + name); + return outDir + File.separator + + resultContainer.getTableForExport().getFilePrefix().toUpperCase(Locale.ROOT) + + name.substring(i); + } + }, + df_section_dateTime_counter_mamberCode { + @Override + public String getFileName(ResultContainer resultContainer, List files) { + return appendSection(resultContainer) + .append(dateTime(resultContainer)) + .append(counter(resultContainer, files)) + .append(memberCode(resultContainer)) + .append(".XML").toString(); + } + }; + + protected StringBuilder appendSection(ResultContainer resultContainer) { + StringBuilder result = new StringBuilder(); + result.append(outDir); + result.append(File.separator); + result.append(resultContainer.getTableForExport().getFilePrefix().toUpperCase(Locale.ROOT)); + result.append('_'); + result.append(SECTION); + return result; + } + + protected StringBuilder dateTime(ResultContainer resultContainer) { + StringBuilder result = new StringBuilder(); + result.append('_'); + result.append("PRC"); + result.append(tsFormatter.format(resultContainer.getRegistrationDateTime())); + return result; + } + + protected StringBuilder counter(ResultContainer resultContainer, List files) { + StringBuilder result = new StringBuilder(); + result.append('_'); + result.append(countSameFilesInDir(resultContainer.getTableForExport().getFilePrefix(), files) + 1); + return result; + } + + protected StringBuilder memberCode(ResultContainer resultContainer) { + StringBuilder result = new StringBuilder(); + result.append('_'); + result.append(resultContainer.getMemberCode()); + return result; + } + + protected Integer countSameFilesInDir(String prefixOfTable, List files) { + final Logger log = LoggerFactory.getLogger(getClass()); + + int res = 0; + String timestampNow = utilFormatter.format(LocalDateTime.now()); + for (SftpFileInfo file : files) { + if (file.isDirectory()) continue; + String name = file.getFilename(); + String[] splitName = name.split("_"); + if (splitName.length < 3) { + log.info("Filename did not contains 3 or 4+ separator \"_\": " + name); + continue; + } + String prefix = splitName[0]; + String timestamp = splitName[2]; + + if (prefix.equalsIgnoreCase(prefixOfTable) && timestamp.contains(timestampNow)) { + if (splitName.length < 4) { + log.warn("Filename did not contains 4+ separator \"_\": " + name); + continue; + } + String counter = splitName[3]; + int positionOfDot = counter.indexOf('.'); + if (positionOfDot != -1) { + counter = counter.substring(0, positionOfDot); + } + res = Integer.max(res, Integer.parseInt(counter)); + } + } + return res; + } + + private static final DateTimeFormatter tsFormatter = DateTimeFormatter.ofPattern("yyMMddHHmm"); + private static final DateTimeFormatter utilFormatter = DateTimeFormatter.ofPattern("yyMMdd"); + + public String getFileName(ResultContainer resultContainer, List files) { + return null; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/StageResult.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/StageResult.java new file mode 100644 index 000000000..f9d6d762e --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/StageResult.java @@ -0,0 +1,7 @@ +package ru.spcex.clearing.xml.exporter.logic.data.enums; + +public enum StageResult { + OK, + ERROR, + COMPLETE +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/Table.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/Table.java new file mode 100644 index 000000000..50447391a --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/enums/Table.java @@ -0,0 +1,57 @@ +package ru.spcex.clearing.xml.exporter.logic.data.enums; + +import ru.clearing.classes.statics.data.sdf.SDf02; +import ru.clearing.classes.statics.data.sdf.SDf03; +import ru.clearing.classes.statics.data.sdf.SDf05; +import ru.clearing.classes.statics.data.sdf.SDf07; +import ru.clearing.classes.statics.data.sdf.SDf51; +import ru.clearing.classes.statics.data.sdf.SDf53; +import ru.clearing.classes.statics.data.sdf.SDf54; +import ru.clearing.classes.statics.data.sdf.SDf56; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.SpcexObjectBase; + +public enum Table { + S_DF02("DF-02", IMDGDistributedNames.Map_SDf02, SDf02.class), + S_DF03("DF-03", IMDGDistributedNames.Map_SDf03, SDf03.class), + S_DF05("DF-05", IMDGDistributedNames.Map_SDf05, SDf05.class), + S_DF07("DF-07", IMDGDistributedNames.Map_SDf07, SDf07.class), + S_DF51("DF-51", IMDGDistributedNames.Map_SDf51, SDf51.class), + S_DF53("DF-53", IMDGDistributedNames.Map_SDf53, SDf53.class), + S_DF54("DF-54", IMDGDistributedNames.Map_SDf54, SDf54.class), + S_DF56("DF-56", IMDGDistributedNames.Map_SDf56, SDf56.class); + + /** + * Префикс имени файла для экспорта + */ + private final String filePrefix; + + /** + * Имя мапы hazelcast + */ + private final String hazelcastMapName; + + /** + * Класс объекта + */ + private final Class entityClass; + + + Table(String filePrefix, String hazelcastMapName, Class entityClass) { + this.filePrefix = filePrefix; + this.hazelcastMapName = hazelcastMapName; + this.entityClass = entityClass; + } + + public String getHazelcastMapName() { + return hazelcastMapName; + } + + public String getFilePrefix() { + return filePrefix; + } + + public Class getEntityClass() { + return entityClass; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/DocumentTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/DocumentTag.java new file mode 100644 index 000000000..2adc35988 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/DocumentTag.java @@ -0,0 +1,148 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement; +import java.time.LocalDate; +import java.time.LocalTime; +import java.util.List; +import java.util.Objects; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.ObjectTag; +import ru.spcex.platform.classes.base.SpcexObjectBase; + +@JacksonXmlRootElement(localName = "DOCUMENT") +public class DocumentTag { + @JacksonXmlProperty(isAttribute = true, localName = "MESSAGEID") + private String messageId; + + @JacksonXmlProperty(isAttribute = true, localName = "MESSAGETYPE") + private String messageType; + + @JacksonXmlProperty(isAttribute = true, localName = "MESSAGENAME") + private String messageName; + + @JacksonXmlProperty(isAttribute = true, localName = "MESSAGEDATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate messageDate; + + @JacksonXmlProperty(isAttribute = true, localName = "MESSAGETIME") + @JsonFormat(pattern = "HH:mm:ss") + private LocalTime messageTime; + + @JacksonXmlProperty(isAttribute = true, localName = "SENDER") + private String sender; + + @JacksonXmlProperty(isAttribute = true, localName = "RECEIVER") + private String receiver; + + @JacksonXmlProperty(localName = "PARENTDOC") + private ParentDocTag parentDoc; + + @JacksonXmlElementWrapper(localName = "OBJECTS") + @JacksonXmlProperty(localName = "OBJECT") + private List> objects; + + public DocumentTag() { + } + + public String getMessageId() { + return messageId; + } + + public void setMessageId(String messageId) { + this.messageId = messageId; + } + + public String getMessageType() { + return messageType; + } + + public void setMessageType(String messageType) { + this.messageType = messageType; + } + + public String getMessageName() { + return messageName; + } + + public void setMessageName(String messageName) { + this.messageName = messageName; + } + + public LocalDate getMessageDate() { + return messageDate; + } + + public void setMessageDate(LocalDate messageDate) { + this.messageDate = messageDate; + } + + public LocalTime getMessageTime() { + return messageTime; + } + + public void setMessageTime(LocalTime messageTime) { + this.messageTime = messageTime; + } + + public String getSender() { + return sender; + } + + public void setSender(String sender) { + this.sender = sender; + } + + public String getReceiver() { + return receiver; + } + + public void setReceiver(String receiver) { + this.receiver = receiver; + } + + public ParentDocTag getParentDoc() { + return parentDoc; + } + + public void setParentDoc(ParentDocTag parentDoc) { + this.parentDoc = parentDoc; + } + + public List> getObjects() { + return objects; + } + + public void setObjects(List> objects) { + this.objects = objects; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DocumentTag that = (DocumentTag) o; + return Objects.equals(messageId, that.messageId) && Objects.equals(messageType, that.messageType) && Objects.equals(messageName, that.messageName) && Objects.equals(messageDate, that.messageDate) && Objects.equals(messageTime, that.messageTime) && Objects.equals(sender, that.sender) && Objects.equals(receiver, that.receiver) && Objects.equals(parentDoc, that.parentDoc) && Objects.equals(objects, that.objects); + } + + @Override + public int hashCode() { + return Objects.hash(messageId, messageType, messageName, messageDate, messageTime, sender, receiver, parentDoc, objects); + } + + @Override + public String toString() { + return "DocumentTag{" + + "messageId='" + messageId + '\'' + + ", messageType='" + messageType + '\'' + + ", messageName='" + messageName + '\'' + + ", messageDate='" + messageDate + '\'' + + ", messageTime='" + messageTime + '\'' + + ", sender='" + sender + '\'' + + ", receiver='" + receiver + '\'' + + ", parentDoc=" + parentDoc + + ", objects=" + objects + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/ParentDocTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/ParentDocTag.java new file mode 100644 index 000000000..cf766ca2a --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/ParentDocTag.java @@ -0,0 +1,40 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags; + +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.util.Objects; + +public class ParentDocTag { + @JacksonXmlProperty(isAttribute = true, localName = "PARENTID") + private String parentId; + + public ParentDocTag() { + } + + public String getParentId() { + return parentId; + } + + public void setParentId(String parentId) { + this.parentId = parentId; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ParentDocTag that = (ParentDocTag) o; + return Objects.equals(parentId, that.parentId); + } + + @Override + public int hashCode() { + return Objects.hashCode(parentId); + } + + @Override + public String toString() { + return "ParentDocTag{" + + "parentId='" + parentId + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF02ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF02ObjectTag.java new file mode 100644 index 000000000..8518e0956 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF02ObjectTag.java @@ -0,0 +1,213 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf02; + +public class DF02ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "CURR_CODE") + private String currCode; + + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + private String account; + + @JacksonXmlProperty(isAttribute = true, localName = "REMAINDER") + private String remainder; + + @JacksonXmlProperty(isAttribute = true, localName = "DEAL") + private String deal; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_CODE") + private String accCode; + + @JacksonXmlProperty(isAttribute = true, localName = "DAT") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate dat; + + @JacksonXmlProperty(isAttribute = true, localName = "MARKET") + private String market; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_NAME") + private String accName; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_TYPE") + private String accType; + + @JacksonXmlProperty(isAttribute = true, localName = "SUMENGAGE") + private String sumengage; + + @JacksonXmlProperty(isAttribute = true, localName = "SUMUNBLOK") + private String sumunblock; + + @JacksonXmlProperty(isAttribute = true, localName = "FILE_TYPE") + private String fileType; + + @JacksonXmlProperty(isAttribute = true, localName = "RESULT") + private String result; + + public DF02ObjectTag() { + super(SDf02.class); + } + + @Override + public void setData(SDf02 entity) { + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + this.currCode = entity.getCurr_code(); + this.account = entity.getAccount(); + this.remainder = entity.getRemainder(); + this.deal = entity.getDeal(); + this.accCode = entity.getAcc_code(); + this.dat = LocalDate.parse(entity.getDat(), dtf); + this.market = entity.getMarket(); + this.accName = entity.getAcc_name(); + this.accType = entity.getAcc_type(); + this.sumengage = entity.getSumengage(); + this.sumunblock = entity.getSumunblock(); + this.fileType = entity.getFile_type(); + this.result = entity.getResult(); + } + + @Override + public String getCurrency(SDf02 entity) { + return entity.getCurr_code(); + } + + public String getCurrCode() { + return currCode; + } + + public void setCurrCode(String currCode) { + this.currCode = currCode; + } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } + + public String getRemainder() { + return remainder; + } + + public void setRemainder(String remainder) { + this.remainder = remainder; + } + + public String getDeal() { + return deal; + } + + public void setDeal(String deal) { + this.deal = deal; + } + + public String getAccCode() { + return accCode; + } + + public void setAccCode(String accCode) { + this.accCode = accCode; + } + + public LocalDate getDat() { + return dat; + } + + public void setDat(LocalDate dat) { + this.dat = dat; + } + + public String getMarket() { + return market; + } + + public void setMarket(String market) { + this.market = market; + } + + public String getAccName() { + return accName; + } + + public void setAccName(String accName) { + this.accName = accName; + } + + public String getAccType() { + return accType; + } + + public void setAccType(String accType) { + this.accType = accType; + } + + public String getSumengage() { + return sumengage; + } + + public void setSumengage(String sumengage) { + this.sumengage = sumengage; + } + + public String getSumunblock() { + return sumunblock; + } + + public void setSumunblock(String sumunblock) { + this.sumunblock = sumunblock; + } + + public String getFileType() { + return fileType; + } + + public void setFileType(String fileType) { + this.fileType = fileType; + } + + public String getResult() { + return result; + } + + public void setResult(String result) { + this.result = result; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF02ObjectTag that = (DF02ObjectTag) o; + return Objects.equals(currCode, that.currCode) && Objects.equals(account, that.account) && Objects.equals(remainder, that.remainder) && Objects.equals(deal, that.deal) && Objects.equals(accCode, that.accCode) && Objects.equals(dat, that.dat) && Objects.equals(market, that.market) && Objects.equals(accName, that.accName) && Objects.equals(accType, that.accType) && Objects.equals(sumengage, that.sumengage) && Objects.equals(sumunblock, that.sumunblock) && Objects.equals(fileType, that.fileType) && Objects.equals(result, that.result); + } + + @Override + public int hashCode() { + return Objects.hash(currCode, account, remainder, deal, accCode, dat, market, accName, accType, sumengage, sumunblock, fileType, result); + } + + @Override + public String toString() { + return "DF02ObjectTag{" + + "currCode='" + currCode + '\'' + + ", account='" + account + '\'' + + ", remainder='" + remainder + '\'' + + ", deal='" + deal + '\'' + + ", accCode='" + accCode + '\'' + + ", dat=" + dat + + ", market='" + market + '\'' + + ", accName='" + accName + '\'' + + ", accType='" + accType + '\'' + + ", sumengage='" + sumengage + '\'' + + ", sumunblock='" + sumunblock + '\'' + + ", fileType='" + fileType + '\'' + + ", result='" + result + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF03ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF03ObjectTag.java new file mode 100644 index 000000000..cd19dd693 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF03ObjectTag.java @@ -0,0 +1,302 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf03; + +public class DF03ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "SEG_TYPE") + private String segType; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_TYPE") + private String docType; + + @JacksonXmlProperty(isAttribute = true, localName = "DOCNM_REF") + private String docnmRef; + + @JacksonXmlProperty(isAttribute = true, localName = "DOCNMPREV") + private String docnmprev; + + @JacksonXmlProperty(isAttribute = true, localName = "C_ACC_DEB") + private String cAccDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "SBANKNAM") + private String sbanknam1; + private String sbanknam2; + private String sbanknam3; + private String sbanknam4; + private String sbanknam5; + + @JacksonXmlProperty(isAttribute = true, localName = "C_ACC_CRED") + private String cAccCred; + + @JacksonXmlProperty(isAttribute = true, localName = "RBANKNAM") + private String rbanknam1; + private String rbanknam2; + private String rbanknam3; + private String rbanknam4; + private String rbanknam5; + + @JacksonXmlProperty(isAttribute = true, localName = "PAY_DATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate payDate; + + @JacksonXmlProperty(isAttribute = true, localName = "PAY_VAL") + private String payVal; + + @JacksonXmlProperty(isAttribute = true, localName = "SUM_DEB") + private String sumDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "SPECIF_1") + private String specif1; + + @JacksonXmlProperty(isAttribute = true, localName = "IMP_RESULT") + private String impResult; + + + public DF03ObjectTag() { + super(SDf03.class); + } + + @Override + public void setData(SDf03 entity) { + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + this.segType = entity.getSeg_type(); + this.docType = entity.getDoc_type(); + this.docnmRef = entity.getDocnm_ref(); + this.docnmprev = entity.getDocnmprev(); + this.cAccDeb = entity.getC_acc_deb(); + this.sbanknam1 = entity.getSbanknam1(); + this.sbanknam2 = entity.getSbanknam2(); + this.sbanknam3 = entity.getSbanknam3(); + this.sbanknam4 = entity.getSbanknam4(); + this.sbanknam5 = entity.getSbanknam5(); + this.cAccCred = entity.getC_acc_cred(); + this.rbanknam1 = entity.getRbanknam1(); + this.rbanknam2 = entity.getRbanknam2(); + this.rbanknam3 = entity.getRbanknam3(); + this.rbanknam4 = entity.getRbanknam4(); + this.rbanknam5 = entity.getRbanknam5(); + this.payDate = LocalDate.parse(entity.getPay_date(), dtf); + this.payVal = entity.getPay_val(); + this.sumDeb = entity.getSum_deb(); + this.specif1 = entity.getSpecif_1(); + this.impResult = entity.getImp_result(); + } + + @Override + public String getCurrency(SDf03 entity) { + return entity.getPay_val(); + } + + public String getSegType() { + return segType; + } + + public void setSegType(String segType) { + this.segType = segType; + } + + public String getDocType() { + return docType; + } + + public void setDocType(String docType) { + this.docType = docType; + } + + public String getDocnmRef() { + return docnmRef; + } + + public void setDocnmRef(String docnmRef) { + this.docnmRef = docnmRef; + } + + public String getDocnmprev() { + return docnmprev; + } + + public void setDocnmprev(String docnmprev) { + this.docnmprev = docnmprev; + } + + public String getcAccDeb() { + return cAccDeb; + } + + public void setcAccDeb(String cAccDeb) { + this.cAccDeb = cAccDeb; + } + + public String getSbanknam1() { + return sbanknam1; + } + + public void setSbanknam1(String sbanknam1) { + this.sbanknam1 = sbanknam1; + } + + public String getSbanknam2() { + return sbanknam2; + } + + public void setSbanknam2(String sbanknam2) { + this.sbanknam2 = sbanknam2; + } + + public String getSbanknam3() { + return sbanknam3; + } + + public void setSbanknam3(String sbanknam3) { + this.sbanknam3 = sbanknam3; + } + + public String getSbanknam4() { + return sbanknam4; + } + + public void setSbanknam4(String sbanknam4) { + this.sbanknam4 = sbanknam4; + } + + public String getSbanknam5() { + return sbanknam5; + } + + public void setSbanknam5(String sbanknam5) { + this.sbanknam5 = sbanknam5; + } + + public String getcAccCred() { + return cAccCred; + } + + public void setcAccCred(String cAccCred) { + this.cAccCred = cAccCred; + } + + public String getRbanknam1() { + return rbanknam1; + } + + public void setRbanknam1(String rbanknam1) { + this.rbanknam1 = rbanknam1; + } + + public String getRbanknam2() { + return rbanknam2; + } + + public void setRbanknam2(String rbanknam2) { + this.rbanknam2 = rbanknam2; + } + + public String getRbanknam3() { + return rbanknam3; + } + + public void setRbanknam3(String rbanknam3) { + this.rbanknam3 = rbanknam3; + } + + public String getRbanknam4() { + return rbanknam4; + } + + public void setRbanknam4(String rbanknam4) { + this.rbanknam4 = rbanknam4; + } + + public String getRbanknam5() { + return rbanknam5; + } + + public void setRbanknam5(String rbanknam5) { + this.rbanknam5 = rbanknam5; + } + + public LocalDate getPayDate() { + return payDate; + } + + public void setPayDate(LocalDate payDate) { + this.payDate = payDate; + } + + public String getPayVal() { + return payVal; + } + + public void setPayVal(String payVal) { + this.payVal = payVal; + } + + public String getSumDeb() { + return sumDeb; + } + + public void setSumDeb(String sumDeb) { + this.sumDeb = sumDeb; + } + + public String getSpecif1() { + return specif1; + } + + public void setSpecif1(String specif1) { + this.specif1 = specif1; + } + + public String getImpResult() { + return impResult; + } + + public void setImpResult(String impResult) { + this.impResult = impResult; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF03ObjectTag that = (DF03ObjectTag) o; + return Objects.equals(segType, that.segType) && Objects.equals(docType, that.docType) && Objects.equals(docnmRef, that.docnmRef) && Objects.equals(docnmprev, that.docnmprev) && Objects.equals(cAccDeb, that.cAccDeb) && Objects.equals(sbanknam1, that.sbanknam1) && Objects.equals(sbanknam2, that.sbanknam2) && Objects.equals(sbanknam3, that.sbanknam3) && Objects.equals(sbanknam4, that.sbanknam4) && Objects.equals(sbanknam5, that.sbanknam5) && Objects.equals(cAccCred, that.cAccCred) && Objects.equals(rbanknam1, that.rbanknam1) && Objects.equals(rbanknam2, that.rbanknam2) && Objects.equals(rbanknam3, that.rbanknam3) && Objects.equals(rbanknam4, that.rbanknam4) && Objects.equals(rbanknam5, that.rbanknam5) && Objects.equals(payDate, that.payDate) && Objects.equals(payVal, that.payVal) && Objects.equals(sumDeb, that.sumDeb) && Objects.equals(specif1, that.specif1) && Objects.equals(impResult, that.impResult); + } + + @Override + public int hashCode() { + return Objects.hash(segType, docType, docnmRef, docnmprev, cAccDeb, sbanknam1, sbanknam2, sbanknam3, sbanknam4, sbanknam5, cAccCred, rbanknam1, rbanknam2, rbanknam3, rbanknam4, rbanknam5, payDate, payVal, sumDeb, specif1, impResult); + } + + @Override + public String toString() { + return "DF03ObjectTag{" + + "segType='" + segType + '\'' + + ", docType='" + docType + '\'' + + ", docnmRef='" + docnmRef + '\'' + + ", docnmprev='" + docnmprev + '\'' + + ", cAccDeb='" + cAccDeb + '\'' + + ", sbanknam1='" + sbanknam1 + '\'' + + ", sbanknam2='" + sbanknam2 + '\'' + + ", sbanknam3='" + sbanknam3 + '\'' + + ", sbanknam4='" + sbanknam4 + '\'' + + ", sbanknam5='" + sbanknam5 + '\'' + + ", cAccCred='" + cAccCred + '\'' + + ", rbanknam1='" + rbanknam1 + '\'' + + ", rbanknam2='" + rbanknam2 + '\'' + + ", rbanknam3='" + rbanknam3 + '\'' + + ", rbanknam4='" + rbanknam4 + '\'' + + ", rbanknam5='" + rbanknam5 + '\'' + + ", payDate=" + payDate + + ", payVal='" + payVal + '\'' + + ", sumDeb='" + sumDeb + '\'' + + ", specif1='" + specif1 + '\'' + + ", impResult='" + impResult + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF05ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF05ObjectTag.java new file mode 100644 index 000000000..2b608adf1 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF05ObjectTag.java @@ -0,0 +1,99 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.time.LocalTime; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf05; + +public class DF05ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "TP") + private BigDecimal tp; + + @JacksonXmlProperty(isAttribute = true, localName = "DT") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate dt; + + @JacksonXmlProperty(isAttribute = true, localName = "TM") + @JsonFormat(pattern = "hh:mm:ss") + private LocalTime tm; + + @JacksonXmlProperty(isAttribute = true, localName = "PR") + private String pr; + + public DF05ObjectTag() { + super(SDf05.class); + } + + @Override + public void setData(SDf05 entity) { + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("hh:mm:ss"); + this.tp = entity.getTp(); + this.dt = entity.getDt(); + this.tm = LocalTime.parse(entity.getTm(), dtf); + this.pr = entity.getPr(); + } + + @Override + public String getCurrency(SDf05 entity) { + return ruCurrency; + } + + public BigDecimal getTp() { + return tp; + } + + public void setTp(BigDecimal tp) { + this.tp = tp; + } + + public LocalDate getDt() { + return dt; + } + + public void setDt(LocalDate dt) { + this.dt = dt; + } + + public LocalTime getTm() { + return tm; + } + + public void setTm(LocalTime tm) { + this.tm = tm; + } + + public String getPr() { + return pr; + } + + public void setPr(String pr) { + this.pr = pr; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF05ObjectTag that = (DF05ObjectTag) o; + return Objects.equals(tp, that.tp) && Objects.equals(dt, that.dt) && Objects.equals(tm, that.tm) && Objects.equals(pr, that.pr); + } + + @Override + public int hashCode() { + return Objects.hash(tp, dt, tm, pr); + } + + @Override + public String toString() { + return "DF05ObjectTag{" + + "tp=" + tp + + ", dt=" + dt + + ", tm=" + tm + + ", pr='" + pr + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF07ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF07ObjectTag.java new file mode 100644 index 000000000..111eeaa5b --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF07ObjectTag.java @@ -0,0 +1,228 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf07; + +public class DF07ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + private String account; + + @JacksonXmlProperty(isAttribute = true, localName = "SUM") + private BigDecimal sum; + + @JacksonXmlProperty(isAttribute = true, localName = "MARKET") + private String market; + + @JacksonXmlProperty(isAttribute = true, localName = "TYPE") + private String type; + + @JacksonXmlProperty(isAttribute = true, localName = "DEAL") + private String deal; + + @JacksonXmlProperty(isAttribute = true, localName = "CLIENTN") + private String clientN; + + @JacksonXmlProperty(isAttribute = true, localName = "INN") + private String inn; + + @JacksonXmlProperty(isAttribute = true, localName = "BIC") + private String bic; + + @JacksonXmlProperty(isAttribute = true, localName = "SPEC") + private String spec; + + @JacksonXmlProperty(isAttribute = true, localName = "NUMBER") + private BigDecimal number; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_NUM") + private String docNum; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_DATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate docDate; + + @JacksonXmlProperty(isAttribute = true, localName = "PAY_VAL") + private String payVal; + + @JacksonXmlProperty(isAttribute = true, localName = "RESULT") + private BigDecimal result; + + + public DF07ObjectTag() { + super(SDf07.class); + } + + @Override + public void setData(SDf07 entity) { + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + this.account = entity.getAccount(); + this.sum = entity.getSum(); + this.market = entity.getMarket(); + this.type = entity.getType(); + this.deal = entity.getDeal(); + this.clientN = entity.getClientN(); + this.inn = entity.getInn(); + this.bic = entity.getBic(); + this.spec = entity.getSpec(); + this.number = entity.getNumber(); + this.result = entity.getResult(); + this.docNum = entity.getDoc_Num(); + this.docDate = LocalDate.parse(entity.getDoc_Date(), dtf); + this.payVal = entity.getPay_val(); + } + + @Override + public String getCurrency(SDf07 entity) { + return entity.getPay_val(); + } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } + + public BigDecimal getSum() { + return sum; + } + + public void setSum(BigDecimal sum) { + this.sum = sum; + } + + public String getMarket() { + return market; + } + + public void setMarket(String market) { + this.market = market; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getDeal() { + return deal; + } + + public void setDeal(String deal) { + this.deal = deal; + } + + public String getClientN() { + return clientN; + } + + public void setClientN(String clientN) { + this.clientN = clientN; + } + + public String getInn() { + return inn; + } + + public void setInn(String inn) { + this.inn = inn; + } + + public String getBic() { + return bic; + } + + public void setBic(String bic) { + this.bic = bic; + } + + public String getSpec() { + return spec; + } + + public void setSpec(String spec) { + this.spec = spec; + } + + public BigDecimal getNumber() { + return number; + } + + public void setNumber(BigDecimal number) { + this.number = number; + } + + public String getDocNum() { + return docNum; + } + + public void setDocNum(String docNum) { + this.docNum = docNum; + } + + public LocalDate getDocDate() { + return docDate; + } + + public void setDocDate(LocalDate docDate) { + this.docDate = docDate; + } + + public String getPayVal() { + return payVal; + } + + public void setPayVal(String payVal) { + this.payVal = payVal; + } + + public BigDecimal getResult() { + return result; + } + + public void setResult(BigDecimal result) { + this.result = result; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF07ObjectTag that = (DF07ObjectTag) o; + return Objects.equals(account, that.account) && Objects.equals(sum, that.sum) && Objects.equals(market, that.market) && Objects.equals(type, that.type) && Objects.equals(deal, that.deal) && Objects.equals(clientN, that.clientN) && Objects.equals(inn, that.inn) && Objects.equals(bic, that.bic) && Objects.equals(spec, that.spec) && Objects.equals(number, that.number) && Objects.equals(docNum, that.docNum) && Objects.equals(docDate, that.docDate) && Objects.equals(payVal, that.payVal) && Objects.equals(result, that.result); + } + + @Override + public int hashCode() { + return Objects.hash(account, sum, market, type, deal, clientN, inn, bic, spec, number, docNum, docDate, payVal, result); + } + + @Override + public String toString() { + return "DF07ObjectTag{" + + "account='" + account + '\'' + + ", sum=" + sum + + ", market='" + market + '\'' + + ", type='" + type + '\'' + + ", deal='" + deal + '\'' + + ", clientN='" + clientN + '\'' + + ", inn='" + inn + '\'' + + ", bic='" + bic + '\'' + + ", spec='" + spec + '\'' + + ", number=" + number + + ", docNum='" + docNum + '\'' + + ", docDate=" + docDate + + ", payVal='" + payVal + '\'' + + ", result=" + result + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF51ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF51ObjectTag.java new file mode 100644 index 000000000..da78b6b2b --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF51ObjectTag.java @@ -0,0 +1,87 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf51; + +public class DF51ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + private String number; + + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + private Long unixtime; + + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + @JsonFormat(pattern = "yyyy-MM-ddhh:mm:ss") + private LocalDateTime datetime; + + public DF51ObjectTag() { + super(SDf51.class); + } + + @Override + public void setData(SDf51 entity) { + // todo: test datetime formatter + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-ddhh:mm:ss"); + this.number = entity.getNumber(); + this.unixtime = LocalDateTime.parse(entity.getDatetime(), dtf) + .atZone(ZoneId.systemDefault()) + .toEpochSecond(); + this.datetime = LocalDateTime.parse(entity.getDatetime(), dtf); + } + + @Override + public String getCurrency(SDf51 entity) { + return ruCurrency; + } + + public String getNumber() { + return number; + } + + public void setNumber(String number) { + this.number = number; + } + + public Long getUnixtime() { + return unixtime; + } + + public void setUnixtime(Long unixtime) { + this.unixtime = unixtime; + } + + public LocalDateTime getDatetime() { + return datetime; + } + + public void setDatetime(LocalDateTime datetime) { + this.datetime = datetime; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF51ObjectTag that = (DF51ObjectTag) o; + return Objects.equals(number, that.number) && Objects.equals(unixtime, that.unixtime) && Objects.equals(datetime, that.datetime); + } + + @Override + public int hashCode() { + return Objects.hash(number, unixtime, datetime); + } + + @Override + public String toString() { + return "DF51ObjectTag{" + + "number='" + number + '\'' + + ", unixtime=" + unixtime + + ", datetime=" + datetime + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF53ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF53ObjectTag.java new file mode 100644 index 000000000..baf19116e --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF53ObjectTag.java @@ -0,0 +1,136 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf53; + +public class DF53ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + private String account; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_NAME") + private String accName; + + @JacksonXmlProperty(isAttribute = true, localName = "DEAL") + private String deal; + + @JacksonXmlProperty(isAttribute = true, localName = "DATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate date; + + @JacksonXmlProperty(isAttribute = true, localName = "STATUS") + private Long status; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_TYPE") + private String accType; + + @JacksonXmlProperty(isAttribute = true, localName = "RESULT") + private String result; + + + public DF53ObjectTag() { + super(SDf53.class); + } + + @Override + public void setData(SDf53 entity) { + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + this.account = entity.getAccount(); + this.accName = entity.getAccName(); + this.deal = entity.getDeal(); + this.date = LocalDate.parse(entity.getDate(), dtf); + this.status = entity.getStatus(); + this.accType = entity.getAccType(); + this.result = entity.getResult(); + } + + @Override + public String getCurrency(SDf53 entity) { + return ruCurrency; + } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } + + public String getAccName() { + return accName; + } + + public void setAccName(String accName) { + this.accName = accName; + } + + public String getDeal() { + return deal; + } + + public void setDeal(String deal) { + this.deal = deal; + } + + public LocalDate getDate() { + return date; + } + + public void setDate(LocalDate date) { + this.date = date; + } + + public Long getStatus() { + return status; + } + + public void setStatus(Long status) { + this.status = status; + } + + public String getAccType() { + return accType; + } + + public void setAccType(String accType) { + this.accType = accType; + } + + public String getResult() { + return result; + } + + public void setResult(String result) { + this.result = result; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF53ObjectTag that = (DF53ObjectTag) o; + return Objects.equals(account, that.account) && Objects.equals(accName, that.accName) && Objects.equals(deal, that.deal) && Objects.equals(date, that.date) && Objects.equals(status, that.status) && Objects.equals(accType, that.accType) && Objects.equals(result, that.result); + } + + @Override + public int hashCode() { + return Objects.hash(account, accName, deal, date, status, accType, result); + } + + @Override + public String toString() { + return "DF53ObjectTag{" + + "account='" + account + '\'' + + ", accName='" + accName + '\'' + + ", deal='" + deal + '\'' + + ", date=" + date + + ", status=" + status + + ", accType='" + accType + '\'' + + ", result='" + result + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF54ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF54ObjectTag.java new file mode 100644 index 000000000..081161e5e --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF54ObjectTag.java @@ -0,0 +1,604 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf54; + +public class DF54ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "SEG_TYPE") + private String segType; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_TYPE") + private String docType; + + @JacksonXmlProperty(isAttribute = true, localName = "DOCNM_REF") + private String docnmRef; + + @JacksonXmlProperty(isAttribute = true, localName = "DOCNMPREV") + private String docnmprev; + + @JacksonXmlProperty(isAttribute = true, localName = "SBANKCODE") + private String sbankcode; + + @JacksonXmlProperty(isAttribute = true, localName = "C_ACC_DEB") + private String cAccDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "SBANKNAM") + private String sbanknam1; + private String sbanknam2; + private String sbanknam3; + private String sbanknam4; + private String sbanknam5; + + @JacksonXmlProperty(isAttribute = true, localName = "RBANKCODE") + private String rbankcode; + + @JacksonXmlProperty(isAttribute = true, localName = "C_ACC_CRED") + private String cAccCred; + + @JacksonXmlProperty(isAttribute = true, localName = "RBANKNAM") + private String rbanknam1; + private String rbanknam2; + private String rbanknam3; + private String rbanknam4; + private String rbanknam5; + + @JacksonXmlProperty(isAttribute = true, localName = "OP_TYPE") + private String opType; + + @JacksonXmlProperty(isAttribute = true, localName = "OP_ORDER") + private String opOrder; + + @JacksonXmlProperty(isAttribute = true, localName = "PAY_DATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate payDate; + + @JacksonXmlProperty(isAttribute = true, localName = "PAY_VAL") + private String payVal; + + @JacksonXmlProperty(isAttribute = true, localName = "SUM_DEB") + private String sumDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "SCLIENTN") + private String sclientn1; + private String sclientn2; + private String sclientn3; + private String sclientn4; + + @JacksonXmlProperty(isAttribute = true, localName = "INN_DEB") + private String innDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "KPP_DEB") + private String kppDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_DEB") + private String accDeb; + + @JacksonXmlProperty(isAttribute = true, localName = "RCLIENTN") + private String rclientn1; + private String rclientn2; + private String rclientn3; + private String rclientn4; + + @JacksonXmlProperty(isAttribute = true, localName = "INN_CRED") + private String innCred; + + @JacksonXmlProperty(isAttribute = true, localName = "KPP_CRED") + private String kppCred; + + @JacksonXmlProperty(isAttribute = true, localName = "ACC_KR_1") + private String accKr1; + + @JacksonXmlProperty(isAttribute = true, localName = "SPECIF_1") + private String specif1; + + @JacksonXmlProperty(isAttribute = true, localName = "SEND_TYPE") + private String sendType; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_RESULT") + private String docResult; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_NUM") + private String docNum; + + @JacksonXmlProperty(isAttribute = true, localName = "DOC_DATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate docDate; + + @JacksonXmlProperty(isAttribute = true, localName = "VALUE_DATE") + @JsonFormat(pattern = "yyyy-MM-dd") + private LocalDate valueDate; + + @JacksonXmlProperty(isAttribute = true, localName = "SWIFT_BEN") + private String swiftBen; + + @JacksonXmlProperty(isAttribute = true, localName = "SWIFT_INT") + private String swiftInt; + + + public DF54ObjectTag() { + super(SDf54.class); + } + + @Override + public void setData(SDf54 entity) { + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + this.segType = entity.getSeg_type(); + this.docType = entity.getDoc_type(); + this.docnmRef = entity.getDocnm_ref(); + this.docnmprev = entity.getDocnmprev(); + this.sbankcode = entity.getSbankcode(); + this.cAccDeb = entity.getC_acc_deb(); + this.sbanknam1 = entity.getSbanknam1(); + this.sbanknam2 = entity.getSbanknam2(); + this.sbanknam3 = entity.getSbanknam3(); + this.sbanknam4 = entity.getSbanknam4(); + this.sbanknam5 = entity.getSbanknam5(); + this.rbankcode = entity.getRbankcode(); + this.cAccCred = entity.getC_acc_cred(); + this.rbanknam1 = entity.getRbanknam1(); + this.rbanknam2 = entity.getRbanknam2(); + this.rbanknam3 = entity.getRbanknam3(); + this.rbanknam4 = entity.getRbanknam4(); + this.rbanknam5 = entity.getRbanknam5(); + this.opType = entity.getOp_type(); + this.opOrder = entity.getOp_order(); + this.payDate = LocalDate.parse(entity.getPay_date(), dtf); + this.payVal = entity.getPay_val(); + this.sumDeb = entity.getSum_deb(); + this.sclientn1 = entity.getSclientn1(); + this.sclientn2 = entity.getSclientn2(); + this.sclientn3 = entity.getSclientn3(); + this.sclientn4 = entity.getSclientn4(); + this.innDeb = entity.getInn_deb(); + this.kppDeb = entity.getKpp_deb(); + this.accDeb = entity.getAcc_deb(); + this.rclientn1 = entity.getRclientn1(); + this.rclientn2 = entity.getRclientn2(); + this.rclientn3 = entity.getRclientn3(); + this.rclientn4 = entity.getRclientn4(); + this.innCred = entity.getInn_cred(); + this.kppCred = entity.getKpp_cred(); + this.accKr1 = entity.getAcc_kr_1(); + this.specif1 = entity.getSpecif_1(); + this.sendType = entity.getSend_type(); + this.docResult = entity.getDoc_result(); + this.docNum = entity.getDoc_Num(); + this.docDate = LocalDate.parse(entity.getDoc_Date(), dtf); + this.valueDate = LocalDate.parse(entity.getValue_date(), dtf); + this.swiftBen = entity.getSwift_ben(); + this.swiftInt = entity.getSwift_int(); + } + + @Override + public String getCurrency(SDf54 entity) { + return entity.getPay_val(); + } + + public String getSegType() { + return segType; + } + + public void setSegType(String segType) { + this.segType = segType; + } + + public String getDocType() { + return docType; + } + + public void setDocType(String docType) { + this.docType = docType; + } + + public String getDocnmRef() { + return docnmRef; + } + + public void setDocnmRef(String docnmRef) { + this.docnmRef = docnmRef; + } + + public String getDocnmprev() { + return docnmprev; + } + + public void setDocnmprev(String docnmprev) { + this.docnmprev = docnmprev; + } + + public String getSbankcode() { + return sbankcode; + } + + public void setSbankcode(String sbankcode) { + this.sbankcode = sbankcode; + } + + public String getcAccDeb() { + return cAccDeb; + } + + public void setcAccDeb(String cAccDeb) { + this.cAccDeb = cAccDeb; + } + + public String getSbanknam1() { + return sbanknam1; + } + + public void setSbanknam1(String sbanknam1) { + this.sbanknam1 = sbanknam1; + } + + public String getSbanknam2() { + return sbanknam2; + } + + public void setSbanknam2(String sbanknam2) { + this.sbanknam2 = sbanknam2; + } + + public String getSbanknam3() { + return sbanknam3; + } + + public void setSbanknam3(String sbanknam3) { + this.sbanknam3 = sbanknam3; + } + + public String getSbanknam4() { + return sbanknam4; + } + + public void setSbanknam4(String sbanknam4) { + this.sbanknam4 = sbanknam4; + } + + public String getSbanknam5() { + return sbanknam5; + } + + public void setSbanknam5(String sbanknam5) { + this.sbanknam5 = sbanknam5; + } + + public String getRbankcode() { + return rbankcode; + } + + public void setRbankcode(String rbankcode) { + this.rbankcode = rbankcode; + } + + public String getcAccCred() { + return cAccCred; + } + + public void setcAccCred(String cAccCred) { + this.cAccCred = cAccCred; + } + + public String getRbanknam1() { + return rbanknam1; + } + + public void setRbanknam1(String rbanknam1) { + this.rbanknam1 = rbanknam1; + } + + public String getRbanknam2() { + return rbanknam2; + } + + public void setRbanknam2(String rbanknam2) { + this.rbanknam2 = rbanknam2; + } + + public String getRbanknam3() { + return rbanknam3; + } + + public void setRbanknam3(String rbanknam3) { + this.rbanknam3 = rbanknam3; + } + + public String getRbanknam4() { + return rbanknam4; + } + + public void setRbanknam4(String rbanknam4) { + this.rbanknam4 = rbanknam4; + } + + public String getRbanknam5() { + return rbanknam5; + } + + public void setRbanknam5(String rbanknam5) { + this.rbanknam5 = rbanknam5; + } + + public String getOpType() { + return opType; + } + + public void setOpType(String opType) { + this.opType = opType; + } + + public String getOpOrder() { + return opOrder; + } + + public void setOpOrder(String opOrder) { + this.opOrder = opOrder; + } + + public LocalDate getPayDate() { + return payDate; + } + + public void setPayDate(LocalDate payDate) { + this.payDate = payDate; + } + + public String getPayVal() { + return payVal; + } + + public void setPayVal(String payVal) { + this.payVal = payVal; + } + + public String getSumDeb() { + return sumDeb; + } + + public void setSumDeb(String sumDeb) { + this.sumDeb = sumDeb; + } + + public String getSclientn1() { + return sclientn1; + } + + public void setSclientn1(String sclientn1) { + this.sclientn1 = sclientn1; + } + + public String getSclientn2() { + return sclientn2; + } + + public void setSclientn2(String sclientn2) { + this.sclientn2 = sclientn2; + } + + public String getSclientn3() { + return sclientn3; + } + + public void setSclientn3(String sclientn3) { + this.sclientn3 = sclientn3; + } + + public String getSclientn4() { + return sclientn4; + } + + public void setSclientn4(String sclientn4) { + this.sclientn4 = sclientn4; + } + + public String getInnDeb() { + return innDeb; + } + + public void setInnDeb(String innDeb) { + this.innDeb = innDeb; + } + + public String getKppDeb() { + return kppDeb; + } + + public void setKppDeb(String kppDeb) { + this.kppDeb = kppDeb; + } + + public String getAccDeb() { + return accDeb; + } + + public void setAccDeb(String accDeb) { + this.accDeb = accDeb; + } + + public String getRclientn1() { + return rclientn1; + } + + public void setRclientn1(String rclientn1) { + this.rclientn1 = rclientn1; + } + + public String getRclientn2() { + return rclientn2; + } + + public void setRclientn2(String rclientn2) { + this.rclientn2 = rclientn2; + } + + public String getRclientn3() { + return rclientn3; + } + + public void setRclientn3(String rclientn3) { + this.rclientn3 = rclientn3; + } + + public String getRclientn4() { + return rclientn4; + } + + public void setRclientn4(String rclientn4) { + this.rclientn4 = rclientn4; + } + + public String getInnCred() { + return innCred; + } + + public void setInnCred(String innCred) { + this.innCred = innCred; + } + + public String getKppCred() { + return kppCred; + } + + public void setKppCred(String kppCred) { + this.kppCred = kppCred; + } + + public String getAccKr1() { + return accKr1; + } + + public void setAccKr1(String accKr1) { + this.accKr1 = accKr1; + } + + public String getSpecif1() { + return specif1; + } + + public void setSpecif1(String specif1) { + this.specif1 = specif1; + } + + public String getSendType() { + return sendType; + } + + public void setSendType(String sendType) { + this.sendType = sendType; + } + + public String getDocResult() { + return docResult; + } + + public void setDocResult(String docResult) { + this.docResult = docResult; + } + + public String getDocNum() { + return docNum; + } + + public void setDocNum(String docNum) { + this.docNum = docNum; + } + + public LocalDate getDocDate() { + return docDate; + } + + public void setDocDate(LocalDate docDate) { + this.docDate = docDate; + } + + public LocalDate getValueDate() { + return valueDate; + } + + public void setValueDate(LocalDate valueDate) { + this.valueDate = valueDate; + } + + public String getSwiftBen() { + return swiftBen; + } + + public void setSwiftBen(String swiftBen) { + this.swiftBen = swiftBen; + } + + public String getSwiftInt() { + return swiftInt; + } + + public void setSwiftInt(String swiftInt) { + this.swiftInt = swiftInt; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF54ObjectTag that = (DF54ObjectTag) o; + return Objects.equals(segType, that.segType) && Objects.equals(docType, that.docType) && Objects.equals(docnmRef, that.docnmRef) && Objects.equals(docnmprev, that.docnmprev) && Objects.equals(sbankcode, that.sbankcode) && Objects.equals(cAccDeb, that.cAccDeb) && Objects.equals(sbanknam1, that.sbanknam1) && Objects.equals(sbanknam2, that.sbanknam2) && Objects.equals(sbanknam3, that.sbanknam3) && Objects.equals(sbanknam4, that.sbanknam4) && Objects.equals(sbanknam5, that.sbanknam5) && Objects.equals(rbankcode, that.rbankcode) && Objects.equals(cAccCred, that.cAccCred) && Objects.equals(rbanknam1, that.rbanknam1) && Objects.equals(rbanknam2, that.rbanknam2) && Objects.equals(rbanknam3, that.rbanknam3) && Objects.equals(rbanknam4, that.rbanknam4) && Objects.equals(rbanknam5, that.rbanknam5) && Objects.equals(opType, that.opType) && Objects.equals(opOrder, that.opOrder) && Objects.equals(payDate, that.payDate) && Objects.equals(payVal, that.payVal) && Objects.equals(sumDeb, that.sumDeb) && Objects.equals(sclientn1, that.sclientn1) && Objects.equals(sclientn2, that.sclientn2) && Objects.equals(sclientn3, that.sclientn3) && Objects.equals(sclientn4, that.sclientn4) && Objects.equals(innDeb, that.innDeb) && Objects.equals(kppDeb, that.kppDeb) && Objects.equals(accDeb, that.accDeb) && Objects.equals(rclientn1, that.rclientn1) && Objects.equals(rclientn2, that.rclientn2) && Objects.equals(rclientn3, that.rclientn3) && Objects.equals(rclientn4, that.rclientn4) && Objects.equals(innCred, that.innCred) && Objects.equals(kppCred, that.kppCred) && Objects.equals(accKr1, that.accKr1) && Objects.equals(specif1, that.specif1) && Objects.equals(sendType, that.sendType) && Objects.equals(docResult, that.docResult) && Objects.equals(docNum, that.docNum) && Objects.equals(docDate, that.docDate) && Objects.equals(valueDate, that.valueDate) && Objects.equals(swiftBen, that.swiftBen) && Objects.equals(swiftInt, that.swiftInt); + } + + @Override + public int hashCode() { + return Objects.hash(segType, docType, docnmRef, docnmprev, sbankcode, cAccDeb, sbanknam1, sbanknam2, sbanknam3, sbanknam4, sbanknam5, rbankcode, cAccCred, rbanknam1, rbanknam2, rbanknam3, rbanknam4, rbanknam5, opType, opOrder, payDate, payVal, sumDeb, sclientn1, sclientn2, sclientn3, sclientn4, innDeb, kppDeb, accDeb, rclientn1, rclientn2, rclientn3, rclientn4, innCred, kppCred, accKr1, specif1, sendType, docResult, docNum, docDate, valueDate, swiftBen, swiftInt); + } + + @Override + public String toString() { + return "DF54ObjectTag{" + + "segType='" + segType + '\'' + + ", docType='" + docType + '\'' + + ", docnmRef='" + docnmRef + '\'' + + ", docnmprev='" + docnmprev + '\'' + + ", sbankcode='" + sbankcode + '\'' + + ", cAccDeb='" + cAccDeb + '\'' + + ", sbanknam1='" + sbanknam1 + '\'' + + ", sbanknam2='" + sbanknam2 + '\'' + + ", sbanknam3='" + sbanknam3 + '\'' + + ", sbanknam4='" + sbanknam4 + '\'' + + ", sbanknam5='" + sbanknam5 + '\'' + + ", rbankcode='" + rbankcode + '\'' + + ", cAccCred='" + cAccCred + '\'' + + ", rbanknam1='" + rbanknam1 + '\'' + + ", rbanknam2='" + rbanknam2 + '\'' + + ", rbanknam3='" + rbanknam3 + '\'' + + ", rbanknam4='" + rbanknam4 + '\'' + + ", rbanknam5='" + rbanknam5 + '\'' + + ", opType='" + opType + '\'' + + ", opOrder='" + opOrder + '\'' + + ", payDate=" + payDate + + ", payVal='" + payVal + '\'' + + ", sumDeb='" + sumDeb + '\'' + + ", sclientn1='" + sclientn1 + '\'' + + ", sclientn2='" + sclientn2 + '\'' + + ", sclientn3='" + sclientn3 + '\'' + + ", sclientn4='" + sclientn4 + '\'' + + ", innDeb='" + innDeb + '\'' + + ", kppDeb='" + kppDeb + '\'' + + ", accDeb='" + accDeb + '\'' + + ", rclientn1='" + rclientn1 + '\'' + + ", rclientn2='" + rclientn2 + '\'' + + ", rclientn3='" + rclientn3 + '\'' + + ", rclientn4='" + rclientn4 + '\'' + + ", innCred='" + innCred + '\'' + + ", kppCred='" + kppCred + '\'' + + ", accKr1='" + accKr1 + '\'' + + ", specif1='" + specif1 + '\'' + + ", sendType='" + sendType + '\'' + + ", docResult='" + docResult + '\'' + + ", docNum='" + docNum + '\'' + + ", docDate=" + docDate + + ", valueDate=" + valueDate + + ", swiftBen='" + swiftBen + '\'' + + ", swiftInt='" + swiftInt + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF56ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF56ObjectTag.java new file mode 100644 index 000000000..53980025c --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/DF56ObjectTag.java @@ -0,0 +1,144 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.util.Objects; +import ru.clearing.classes.statics.data.sdf.SDf56; + +public class DF56ObjectTag extends ObjectTag { + @JacksonXmlProperty(isAttribute = true, localName = "NUMBER") + private String number; + + @JacksonXmlProperty(isAttribute = true, localName = "SUNIXTIME") + private Long startUnixtime; + + @JacksonXmlProperty(isAttribute = true, localName = "SDATETIME") + @JsonFormat(pattern = "yyyy-MM-ddhh:mm:ss") + private LocalDateTime startDatetime; + + @JacksonXmlProperty(isAttribute = true, localName = "EUNIXTIME") + private Long endUnixtime; + + @JacksonXmlProperty(isAttribute = true, localName = "EDATETIME") + @JsonFormat(pattern = "yyyy-MM-ddhh:mm:ss") + private LocalDateTime endDatetime; + + @JacksonXmlProperty(isAttribute = true, localName = "ACCOUNT") + private String account; + + @JacksonXmlProperty(isAttribute = true, localName = "DEAL") + private String deal; + + + public DF56ObjectTag() { + super(SDf56.class); + } + + @Override + public void setData(SDf56 entity) { + // todo: check datatime formatter + final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-ddhh:mm:ss"); + + this.number = entity.getNumber(); + this.startUnixtime = LocalDateTime.parse(entity.getStart_datetime(), dtf) + .atZone(ZoneId.systemDefault()) + .toEpochSecond(); + this.startDatetime = LocalDateTime.parse(entity.getStart_datetime(), dtf); + this.endUnixtime = LocalDateTime.parse(entity.getEnd_datetime(), dtf) + .atZone(ZoneId.systemDefault()) + .toEpochSecond(); + this.endDatetime = LocalDateTime.parse(entity.getEnd_datetime(), dtf); + this.account = entity.getAccount(); + this.deal = entity.getDeal(); + } + + @Override + public String getCurrency(SDf56 entity) { + return ruCurrency; + } + + public String getNumber() { + return number; + } + + public void setNumber(String number) { + this.number = number; + } + + public Long getStartUnixtime() { + return startUnixtime; + } + + public void setStartUnixtime(Long startUnixtime) { + this.startUnixtime = startUnixtime; + } + + public LocalDateTime getStartDatetime() { + return startDatetime; + } + + public void setStartDatetime(LocalDateTime startDatetime) { + this.startDatetime = startDatetime; + } + + public Long getEndUnixtime() { + return endUnixtime; + } + + public void setEndUnixtime(Long endUnixtime) { + this.endUnixtime = endUnixtime; + } + + public LocalDateTime getEndDatetime() { + return endDatetime; + } + + public void setEndDatetime(LocalDateTime endDatetime) { + this.endDatetime = endDatetime; + } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } + + public String getDeal() { + return deal; + } + + public void setDeal(String deal) { + this.deal = deal; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DF56ObjectTag that = (DF56ObjectTag) o; + return Objects.equals(number, that.number) && Objects.equals(startUnixtime, that.startUnixtime) && Objects.equals(startDatetime, that.startDatetime) && Objects.equals(endUnixtime, that.endUnixtime) && Objects.equals(endDatetime, that.endDatetime) && Objects.equals(account, that.account) && Objects.equals(deal, that.deal); + } + + @Override + public int hashCode() { + return Objects.hash(number, startUnixtime, startDatetime, endUnixtime, endDatetime, account, deal); + } + + @Override + public String toString() { + return "DF56ObjectTag{" + + "number='" + number + '\'' + + ", startUnixtime=" + startUnixtime + + ", startDatetime=" + startDatetime + + ", endUnixtime=" + endUnixtime + + ", endDatetime=" + endDatetime + + ", account='" + account + '\'' + + ", deal='" + deal + '\'' + + '}'; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/ObjectTag.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/ObjectTag.java new file mode 100644 index 000000000..d29abcddf --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/data/tags/objects/ObjectTag.java @@ -0,0 +1,30 @@ +package ru.spcex.clearing.xml.exporter.logic.data.tags.objects; + +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.enumeration.CurrencyCode; + +@JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION) +@JsonSubTypes({ + @JsonSubTypes.Type(DF02ObjectTag.class), + @JsonSubTypes.Type(DF03ObjectTag.class), + @JsonSubTypes.Type(DF05ObjectTag.class), + @JsonSubTypes.Type(DF07ObjectTag.class), + @JsonSubTypes.Type(DF51ObjectTag.class), + @JsonSubTypes.Type(DF53ObjectTag.class), + @JsonSubTypes.Type(DF54ObjectTag.class), + @JsonSubTypes.Type(DF56ObjectTag.class), +}) +public abstract class ObjectTag { + public final static String ruCurrency = CurrencyCode.RUB.getKey(); + public Class clazz; + + public ObjectTag (Class clazz) { + this.clazz = clazz; + } + + public abstract void setData(T1 entity); + + public abstract String getCurrency(T1 entity); +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/ExportFromHazelcast.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/ExportFromHazelcast.java new file mode 100644 index 000000000..bec280aac --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/ExportFromHazelcast.java @@ -0,0 +1,162 @@ +package ru.spcex.clearing.xml.exporter.logic.stages; + +import static ru.spcex.clearing.platform.messaging.domain.Consts.PAIR_SDF; +import static ru.spcex.clearing.xml.exporter.logic.data.tags.objects.ObjectTag.ruCurrency; + +import com.fasterxml.jackson.dataformat.xml.XmlMapper; +import java.io.File; +import java.time.LocalDate; +import java.time.LocalTime; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.function.Supplier; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.platform.messaging.domain.cud.utilities.PairSdfRequest; +import ru.spcex.clearing.platform.messaging.serialization.LogFormatter; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.xml.exporter.config.SFTPConfig; +import ru.spcex.clearing.xml.exporter.config.settings.ExportXMLServiceSettings; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; +import ru.spcex.clearing.xml.exporter.logic.data.enums.StageResult; +import ru.spcex.clearing.xml.exporter.logic.data.enums.Table; +import ru.spcex.clearing.xml.exporter.logic.data.tags.DocumentTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.ParentDocTag; +import ru.spcex.clearing.xml.exporter.logic.data.tags.objects.ObjectTag; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.enumeration.CurrencyCode; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +@Component +public class ExportFromHazelcast extends Stage { + private final ExportXMLServiceSettings settings; + private final ImdgProvider imdgProvider; + private final SFTPConfig.XmlGateway gateway; + private final XmlMapper xmlMapper; + private final Map> objectTagMap; + private final Supplier kafkaSender; + + public ExportFromHazelcast(ExportXMLServiceSettings settings, + ImdgProvider imdgProvider, + SFTPConfig.XmlGateway gateway, + @Qualifier("xmlMapper") XmlMapper xmlMapper, + @Qualifier("mapOfTable") Map> objectTagMap, + Supplier kafkaSender) { + this.settings = settings; + this.imdgProvider = imdgProvider; + this.gateway = gateway; + this.xmlMapper = xmlMapper; + this.objectTagMap = objectTagMap; + this.kafkaSender = kafkaSender; + } + + @Override + public StageResult process(ResultContainer resultContainer) { + Objects.requireNonNull(resultContainer.getTableForExport()); + Objects.requireNonNull(resultContainer.getFileForExport()); + Table table = resultContainer.getTableForExport(); + + DocumentTag documentTag = new DocumentTag(); + ParentDocTag parentDocTag = new ParentDocTag(); + parentDocTag.setParentId(""); + // todo: Добавить данные DocumentTag'а + documentTag.setMessageId(""); + documentTag.setMessageType(table.getFilePrefix().replace("-", "")); + documentTag.setMessageName(""); + documentTag.setMessageDate(LocalDate.now()); + documentTag.setMessageTime(LocalTime.now()); + documentTag.setSender(""); + documentTag.setReceiver(""); + documentTag.setParentDoc(parentDocTag); + + Imdg map = imdgProvider.getImdg(table.getHazelcastMapName(), table.getEntityClass()); + File xmlFile = resultContainer.getFileForExport(); + String currency = null; + String path = null; + boolean writeOk = false; + boolean emptyMap = true; + + try { + Collection tableRows; + if (resultContainer.getGroupId() != null) { + Map queryParams = Map.of("generationId", resultContainer.getGroupId()); + tableRows = map.getCollectionObjectsByFieldValues(queryParams); + } else { + tableRows = map.getAllValues(); + } + if (tableRows.isEmpty()) { + log.info("uuid {}. Map {} is empty, generationId {}", resultContainer.getUuid(), resultContainer.getTableForExport().getHazelcastMapName(), resultContainer.getGroupId()); + return StageResult.COMPLETE; + } else { + log.debug("uuid {}. Selected {} records from map {}, generationId {}", resultContainer.getUuid(), + tableRows.size(), resultContainer.getTableForExport().getHazelcastMapName(), resultContainer.getGroupId()); + } + if (Table.S_DF02 == resultContainer.getTableForExport()) { + log.trace("Sort S_DF02 items"); // Сортировка по возрастанию id, чтобы сохранить последовательность строк SDF02, как в SDF01 + tableRows = new ArrayList(tableRows); + ((ArrayList) tableRows).sort(Comparator.comparing(SpcexObjectBase::getId)); + } + + documentTag.setObjects(addObjectTags(tableRows, table)); + log.info("DOCUMENT TAG = {}", documentTag); + xmlMapper.writeValue(xmlFile, documentTag); + + if (CurrencyCode.isRub(currency)) + path = settings.getStore().getOutPayValDir().get(ruCurrency); + else path = settings.getStore().getOutPayValDir().get(currency); + + if (path == null) + throw new Exception("Get unknown currency=" + currency + ", need will be adding settings like 'export-xml-service.store.out-pay-val-dir.RUB=/RUB' and restart app"); + writeOk = true; + emptyMap = tableRows.isEmpty(); + + + } catch (Exception e) { + log.error(String.format("uuid %s. Can't export table %s (map %s) to file %s. Table was skipped.", + resultContainer.getUuid(), table, table.getHazelcastMapName(), xmlFile), e); + return StageResult.ERROR; + } finally { + if (!writeOk || emptyMap) { + log.debug("Delete empty XML temp file \"{}\"", resultContainer.getFileForExport()); + boolean deleteOk = resultContainer.getFileForExport().delete(); + if (!deleteOk) { + log.warn("Can't delete file {}", resultContainer.getFileForExport().getName()); + } + } else { + log.debug("uuid {}, send to SFTP path \"{}\"", resultContainer.getUuid(), path); + //gateway.sendToSftp(xmlFile, path); + if (Table.S_DF02.equals(resultContainer.getTableForExport())) { + sendPairSdfRequest(resultContainer); + } + } + } + + return StageResult.OK; + } + + private List> addObjectTags(Collection tableRows, Table table) { + List> result = new ArrayList<>(); + + for (T row : tableRows) { + ObjectTag value = (ObjectTag) objectTagMap.get(table); + value.setData(row); + result.add(value); + } + + return result; + } + + private void sendPairSdfRequest(ResultContainer resultContainer) { + PairSdfRequest request = new PairSdfRequest(); + request.setGenerationId(resultContainer.getGroupId()); + request.setFileNameSDf(resultContainer.getFileForExport().getName()); + request.setTableSDf(resultContainer.getTableForExport().getFilePrefix()); + Long msgId = kafkaSender.get().sendRequestToQueue(PAIR_SDF, request); + log.info("Send PairSdfRequest={} message id={} to kafka \"{}\"", LogFormatter.toString(request), msgId, PAIR_SDF); + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/Journal.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/Journal.java new file mode 100644 index 000000000..9e28cdd01 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/Journal.java @@ -0,0 +1,91 @@ +package ru.spcex.clearing.xml.exporter.logic.stages; + +import static ru.spcex.clearing.platform.messaging.domain.Consts.EXPORT_COMPLETED; + +import java.io.File; +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Supplier; +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.Component; +import ru.spcex.clearing.platform.messaging.domain.cud.system.JournalSdf; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; +import ru.spcex.clearing.xml.exporter.logic.data.enums.StageResult; +import ru.spcex.clearing.xml.exporter.logic.data.enums.Table; + +@Component +public class Journal extends Stage implements InitializingBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final Supplier kafkaSender; + + @Autowired + public Journal(Supplier kafkaSender) { + this.kafkaSender = kafkaSender; + } + + @Override + public boolean skipCompleted() { + return false; + } + + @Override + public StageResult process(ResultContainer resultContainer) { + if (kafkaSender == null) { + log.info("kafka producer settings missing; kafka messages to journal-service are not enabled."); + return StageResult.COMPLETE; + } + JournalSdf journalSdf = new JournalSdf(); + //todo read file attibutes + journalSdf.setRegistrationDate(resultContainer.getRegistrationDateTime().toLocalDate()); + journalSdf.setRegistrationTime(resultContainer.getRegistrationDateTime().toLocalTime()); + journalSdf.setRegistrationNumber(resultContainer.getGroupId()); + journalSdf.setDocumentName(documentNames.get(resultContainer.getTableForExport())); + journalSdf.setDossierNumber(dossierNumber.get(resultContainer.getTableForExport())); + journalSdf.setResultStatus(StageResult.ERROR.equals(resultContainer.getLastStageResult()) ? "NACK" : "ACK"); + kafkaSender.get().sendRequestToQueue(EXPORT_COMPLETED, journalSdf); + + //удалим временный файл + File xmlFile = resultContainer.getFileForExport(); +// try { +// log.debug("Uuid {}, delete temp file \"{}\"", resultContainer.getUuid(), xmlFile); +// Files.deleteIfExists(xmlFile.toPath()); +// } catch (IOException e) { +// throw new RuntimeException(e); +// } + // Надо сохранять для разбора истории и отладки по логам + log.debug("Uuid {}, save temp file \"{}\"", resultContainer.getUuid(), xmlFile); + return StageResult.COMPLETE; + } + + @Override + public void afterPropertiesSet() { + } + + private static final Map documentNames = new EnumMap<>(Table.class); + static { + documentNames.put(Table.S_DF02, "Уведомлений об исполнении операции загрузки денежных средств или уведомление об ошибке"); + documentNames.put(Table.S_DF03, "Сводное платёжное поручение по итогу проведения расчетов, направляемое в РО"); + documentNames.put(Table.S_DF05, "Уведомление о завершении расчетов в секции"); + documentNames.put(Table.S_DF07, "Подтверждение о загрузке Уведомления о возврате ден.ср. по договору депозита"); + documentNames.put(Table.S_DF51, "Запрос остатков по всем счетам, направляемый в РО"); + documentNames.put(Table.S_DF53, ""); + documentNames.put(Table.S_DF54, "Распоряжение на списание денежных средств УК категории В (с клирингового счета)"); + documentNames.put(Table.S_DF56, ""); + } + + private static final Map dossierNumber = new EnumMap<>(Table.class); + static { + dossierNumber.put(Table.S_DF02, "07-50"); + dossierNumber.put(Table.S_DF03, "07-51"); + dossierNumber.put(Table.S_DF05, "07-53"); + dossierNumber.put(Table.S_DF07, "07-58"); + dossierNumber.put(Table.S_DF51, "07-55"); + dossierNumber.put(Table.S_DF53, ""); + dossierNumber.put(Table.S_DF54, "07-48"); + dossierNumber.put(Table.S_DF56, ""); + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/PrepareXMLFile.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/PrepareXMLFile.java new file mode 100644 index 000000000..64b4c1144 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/PrepareXMLFile.java @@ -0,0 +1,90 @@ +package ru.spcex.clearing.xml.exporter.logic.stages; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.EnumMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.integration.sftp.session.SftpFileInfo; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.xml.exporter.config.SFTPConfig; +import ru.spcex.clearing.xml.exporter.config.settings.ExportXMLServiceSettings; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; +import ru.spcex.clearing.xml.exporter.logic.data.enums.FilenameTemplate; +import ru.spcex.clearing.xml.exporter.logic.data.enums.StageResult; +import ru.spcex.clearing.xml.exporter.logic.data.enums.Table; + +@Component +public class PrepareXMLFile extends Stage implements InitializingBean { + public static final String SECTION = "S"; + private final ExportXMLServiceSettings settings; + public static String outDir; + private final SFTPConfig.XmlGateway gateway; + + public PrepareXMLFile(ExportXMLServiceSettings settings, SFTPConfig.XmlGateway gateway) { + this.settings = settings; + this.gateway = gateway; + } + + @Override + public StageResult process(ResultContainer resultContainer) { + Objects.requireNonNull(resultContainer.getTableForExport()); + if (settings.getStore().getOutPayValDir() == null || settings.getStore().getOutPayValDir().size() == 0) { + log.error("No SFTP scanning directories, need will be adding settings like 'export-xml-service.store.out-pay-val-dir.RUB=/RUB' and restart app"); + return StageResult.ERROR; + } + List files = new ArrayList<>(); + log.trace("Get files from SFTP paths: {}", settings.getStore().getOutPayValDir().values()); + for (String path : settings.getStore().getOutPayValDir().values()) { + files.addAll(gateway.listFiles(path)); + } + log.info("There are {} files on the sFTP server in the search directories.", files.size()); + Table table = resultContainer.getTableForExport(); + LocalDateTime currentDateTime = LocalDateTime.now(); + resultContainer.setRegistrationDateTime(currentDateTime); + File xmlFile = new File(nameTemplates.get(table).getFileName(resultContainer, files)); + try { + Path xmlFilePath = xmlFile.toPath(); + Files.deleteIfExists(xmlFilePath); + Files.createFile(xmlFilePath); + } catch (Exception e) { + log.error(String.format("uuid %s. Can't create file %s", resultContainer.getUuid(), xmlFile.getName()), e); + return StageResult.ERROR; + } + resultContainer.setFileForExport(xmlFile); + log.info("uuid {}. Rows from {} with generationId {} will be export to temp file \"{}\"", resultContainer.getUuid(), + resultContainer.getTableForExport().getFilePrefix(), resultContainer.getGroupId(), xmlFile); + return StageResult.OK; + } + + + @Override + public void afterPropertiesSet() throws Exception { + String outDirPath = settings.getStore().getLocalTempDir(); + File outDirFile = new File(outDirPath); + if (outDirFile.exists() && !outDirFile.isDirectory()) + throw new IOException("Output directory " + outDirPath + " is file."); + if (!outDirFile.exists()) Files.createDirectories(outDirFile.toPath()); + this.outDir = outDirPath; + log.info("Output directory: {}", outDirFile.getAbsolutePath()); + } + + private static final Map nameTemplates = new EnumMap<>(Table.class); + + static { + nameTemplates.put(Table.S_DF02, FilenameTemplate.df_section_sameName); + nameTemplates.put(Table.S_DF03, FilenameTemplate.df_section_dateTime_counter); + nameTemplates.put(Table.S_DF05, FilenameTemplate.df_section_dateTime); + nameTemplates.put(Table.S_DF07, FilenameTemplate.df_section_sameName); + nameTemplates.put(Table.S_DF51, FilenameTemplate.df_section_dateTime_counter); + nameTemplates.put(Table.S_DF53, FilenameTemplate.df_section_sameName); + nameTemplates.put(Table.S_DF54, FilenameTemplate.df_section_dateTime_counter); + nameTemplates.put(Table.S_DF56, FilenameTemplate.df_section_dateTime_counter); + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/Stage.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/Stage.java new file mode 100644 index 000000000..97e850c27 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/logic/stages/Stage.java @@ -0,0 +1,16 @@ +package ru.spcex.clearing.xml.exporter.logic.stages; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; +import ru.spcex.clearing.xml.exporter.logic.data.enums.StageResult; + +public abstract class Stage { + protected Logger log = LoggerFactory.getLogger(getClass()); + + public abstract StageResult process(ResultContainer resultContainer); + + public boolean skipCompleted() { + return true; + } +} diff --git a/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/services/CommandService.java b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/services/CommandService.java new file mode 100644 index 000000000..bdd19a36b --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/java/ru/spcex/clearing/xml/exporter/services/CommandService.java @@ -0,0 +1,103 @@ +package ru.spcex.clearing.xml.exporter.services; + +import java.util.Arrays; +import java.util.Optional; +import org.apache.kafka.clients.consumer.Consumer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.stereotype.Service; +import ru.spcex.clearing.platform.messaging.domain.BaseRequest; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.clearing.SdfClearingRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.platform.messaging.service.QueueConsumer; +import ru.spcex.clearing.xml.exporter.logic.Processor; +import ru.spcex.clearing.xml.exporter.logic.data.ResultContainer; +import ru.spcex.clearing.xml.exporter.logic.data.enums.Table; +import ru.spcex.platform.enumeration.Task; +import ru.spcex.platform.imdg.api.ImdgProvider; + +@Service +public class CommandService extends QueueConsumer implements InitializingBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final ImdgProvider imdgProvider; + private final Processor processor; + + public CommandService(Consumer kafkaQueue, + ImdgProvider imdgProvider, + Processor processor) { + super(kafkaQueue); + this.imdgProvider = imdgProvider; + this.processor = processor; + } + + @Override + public void afterPropertiesSet() throws Exception { + callback(ExportToFileRequest.class) + .setConsumer(this::process) + .forDestination(Consts.EXPORT_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF02, r)) + .forDestination(Consts.SDF02_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF03, r)) // todo необходимо в отдельную папку: "в отдельную директорию SettlementHouse_Fail (чтобы не отдавать такие файлы в ПРЦ" + .forDestination(Consts.SDF03_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF05, r)) + .forDestination(Consts.SDF05_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF07, r)) + .forDestination(Consts.SDF07_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF51, r)) + .forDestination(Consts.SDF51_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF53, r)) + .forDestination(Consts.SDF53_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF54, r)) + .forDestination(Consts.SDF54_PROCESS, callbacks::put); + callback(SdfClearingRequest.class) + .setConsumer(r -> processSpecial(Table.S_DF56, r)) + .forDestination(Consts.SDF56_PROCESS, callbacks::put); + + callback(LauncherCommandRequest.class) + .setConsumer(r -> processByLauncher(Table.S_DF54, r)) + .forDestination(Task.dbfExport_OUTV.topic(), callbacks::put); // todo: добавить код для экспорта XML + + init(); + } + + private void process(BaseRequest systemRequest) { + ExportToFileRequest request = systemRequest.getRequestPayload(); + Optional tableForExport = Arrays.stream(Table.values()). + filter(table -> table.getFilePrefix().equalsIgnoreCase(request.getNameOfTable())).findFirst(); + if (tableForExport.isEmpty()) { + throw new IllegalStateException(String.format("Unsupported table prefix: %s", request.getNameOfTable())); + } + ResultContainer resultContainer = ResultContainer.createNewTask(tableForExport.get()); + resultContainer.setGroupId(request.getSdfGroupId()); + resultContainer.setSourceName(request.getFileName()); + processor.process(resultContainer); + } + + private void processSpecial(Table table, BaseRequest systemRequest) { + SdfClearingRequest request = systemRequest.getRequestPayload(); + ResultContainer resultContainer = ResultContainer.createNewTask(table); + resultContainer.setGroupId(request.getGroupId()); + resultContainer.setSourceName(null); + processor.process(resultContainer); + } + + private void processByLauncher(Table table, BaseRequest systemRequest) { + LauncherCommandRequest request = systemRequest.getRequestPayload(); + log.info("RequestId={}, LauncherCommandRequest task={}. Table {}", systemRequest.getId(), request.getTaskName(), table); + ResultContainer resultContainer = ResultContainer.createNewTask(table); + resultContainer.setGroupId(null); + resultContainer.setSourceName(null); + processor.process(resultContainer); + } +} diff --git a/clearing-parent/xml-exporter/src/main/resources/application.properties b/clearing-parent/xml-exporter/src/main/resources/application.properties new file mode 100644 index 000000000..8501f4510 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/resources/application.properties @@ -0,0 +1,32 @@ +spring.main.web-application-type=none + +export-xml-service.hazelcast.cluster-members=10.200.200.181:5701 +export-xml-service.hazelcast.login=dev +export-xml-service.hazelcast.password=dev-pass + +export-xml-service.common.encoding=cp866 +export-xml-service.common.threads-count=10 + +export-xml-service.store.local-temp-dir=D:\\docs and T3\\clearing\\xml\\ +# код валюты должен быть в верхнем регистре, например для рублей - "RUB" (*.RUB=export/rub/).RUB=export/rub/ +export-xml-service.store.out-pay-val-dir.RUB=export/rub/ +export-xml-service.store.out-pay-val-dir.EUR=export/eur/ +export-xml-service.store.user:tester +export-xml-service.store.password=password +export-xml-service.store.server-ip=10.230.238.53 +export-xml-service.store.server-port=2222 + +export-xml-service.kafka-consumer.bootstrap-servers=localhost:9092 +export-xml-service.kafka-consumer.group-id=dev-group-balance-service +export-xml-service.kafka-consumer.enable-auto-commit=false +export-xml-service.kafka-consumer.session-timeout-ms=30000 +export-xml-service.kafka-consumer.auto-offset-reset=latest +export-xml-service.kafka-consumer.linger-ms=1 +export-xml-service.kafka-consumer.buffer-memory=33554432 + +export-xml-service.kafka-producer.bootstrap-servers=localhost:9092 +export-xml-service.kafka-producer.acks=all +export-xml-service.kafka-producer.retries=0 +export-xml-service.kafka-producer.batch-size=16384 +export-xml-service.kafka-producer.linger-ms=1 +export-xml-service.kafka-producer.buffer-memory=33554432 diff --git a/clearing-parent/xml-exporter/src/main/resources/logback.xml b/clearing-parent/xml-exporter/src/main/resources/logback.xml new file mode 100644 index 000000000..af6cf0140 --- /dev/null +++ b/clearing-parent/xml-exporter/src/main/resources/logback.xml @@ -0,0 +1,56 @@ + + + + + + + + + + ${CONSOLE_LOG_PATTERN} + utf-8 + + + + + ${LOG_PATH}/${FILE_NAME}-text.log + + + ${FILE_LOG_PATTERN} + utf8 + + + ${LOG_PATH}/${FILE_NAME}-text.%d{yyyy-MM-dd}.%i.gz + + + 100MB + + 10 + + + + + ${LOG_PATH}/${FILE_NAME}-json.log + + + ${LOG_PATH}/${FILE_NAME}-json.%d{yyyy-MM-dd}.%i.gz + + + 100MB + + 10 + + + + + + + + + + + + + + + \ No newline at end of file