Merge remote-tracking branch 'origin/dev' into dev

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/AbstractServiceTest.java

@@ -1,19 +1,46 @@
 package ru.spcex.clearing.balance.service;
 
+import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
-import ru.spcex.clearing.balance.config.BalanceImdgTestConfig;
+import ru.clearing.classes.statics.data.account.Account;
-import ru.spcex.clearing.balance.config.KafkaSenderConfig;
+import ru.clearing.classes.statics.data.company.Company;
-import ru.spcex.clearing.balance.config.KafkaTestConfig;
+import ru.spcex.clearing.balance.config.*;
-import ru.spcex.clearing.balance.config.ValidationConfig;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
+
+import javax.annotation.PostConstruct;
+import java.util.concurrent.atomic.AtomicLong;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
         AccountBalanceService.class,
+        Sdf01Executor.class,
+        LoggingService.class,
+        MessagesConfig.class,
         ValidationConfig.class,
         BalanceImdgTestConfig.class,
         KafkaSenderConfig.class,
         KafkaTestConfig.class})
 public abstract class AbstractServiceTest {
+    protected AtomicLong currentId = new AtomicLong(0L);
+    protected IMap<Long, Company> companyMap;
+    protected IMap<Long, Account> accountMap;
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider hazelcast;
+
+    @PostConstruct
+    void init() {
+        hazelcast.waitAvailable();
+        ImdgHazelcast<Company> companyImdg = (ImdgHazelcast<Company>) hazelcast.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        ImdgHazelcast<Account> accountImdg = (ImdgHazelcast<Account>) hazelcast.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        companyMap = companyImdg.getMap();
+        accountMap = accountImdg.getMap();
+    }
+
 }

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/AccountBalanceServiceTest.java

@@ -1,23 +1,17 @@
 package ru.spcex.clearing.balance.service;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.AccountBalance;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.spcex.clearing.balance.errors.BalanceError;
 import ru.spcex.clearing.balance.utils.MatcherFactory.Matcher;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.AccountType;
 import ru.spcex.platform.enumeration.BalanceAccountType;
 import ru.spcex.platform.enumeration.Status;
-import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 
-import javax.annotation.PostConstruct;
 import java.math.BigDecimal;
 
 import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
@@ -37,22 +31,16 @@ class AccountBalanceServiceTest extends AbstractServiceTest {
     private final String cashMovementCurrencyCodeUpdate = "cash";
     @Autowired
     AccountBalanceService accountBalanceService;
-    @Autowired
-    @Qualifier("hazelcastServiceTest")
-    private ImdgProvider hazelcast;
-
-    private IMap<Long, Company> companyMap;
-    private IMap<Long, Account> accountMap;
-
-    @PostConstruct
-    void init() {
-        hazelcast.waitAvailable();
-        ImdgHazelcast<Company> companyImdg = (ImdgHazelcast<Company>) hazelcast.getImdg(IMDGDistributedNames.Map_Company, Company.class);
-        ImdgHazelcast<Account> accountImdg = (ImdgHazelcast<Account>) hazelcast.getImdg(IMDGDistributedNames.Map_Account, Account.class);
-        companyMap = companyImdg.getMap();
-        accountMap = accountImdg.getMap();
-    }
 
+    /**
+     * {@link AccountBalanceService#createAccountBalance(Long addresseeId, Long accountId, BigDecimal amount, String cashMovementCurrencyCode)}<br>
+     * Тест проверяет генерацию сущности {@link AccountResult}<br>
+     * Входные параметры:<br>
+     * addresseeId - {@link Company#id}<br>
+     * accountId - {@link Account#id}<br>
+     * amount - сумма<br>
+     * cashMovementCurrencyCode - код<br>
+     */
     @Test
     void createAccountBalance() {
         Company company = new Company();
@@ -108,21 +96,30 @@ class AccountBalanceServiceTest extends AbstractServiceTest {
         ACCOUNT_BALANCE_MATCHER.assertMatch(resultUpdate, predictableUpdateResult);
     }
 
+    /**
+     * {@link AccountBalanceService#createAccountBalance(Long addresseeId, Long accountId, BigDecimal amount, String cashMovementCurrencyCode)}<br>
+     * Тест проверяет валидацию<br>
+     * Входные параметры:<br>
+     * addresseeId - {@link Company#id}<br>
+     * accountId - {@link Account#id}<br>
+     * amount - сумма<br>
+     * cashMovementCurrencyCode - код<br>
+     */
     @Test
     void validatedCreateAccountBalance() {
+        //CompanyNotFound
         AccountResult predictableResult;
         predictableResult = new AccountResult(new EnumMessage(BalanceError.CompanyNotFound));
 
         AccountResult result = accountBalanceService.createAccountBalance(addresseeIdNew, accountIdNew, amountNew, cashMovementCurrencyCodeNew);
         ACCOUNT_BALANCE_MATCHER.assertMatch(result, predictableResult);
 
+        //AccountNotPresent accountType=null
         Company company = new Company();
         company.setId(addresseeIdNew);
         companyMap.put(id, company);
-
         Account account = new Account();
         account.setId(accountIdNew);
-//        account.setAccountType(AccountType.Clrn.getKey());
         account.setAccountStatus(Status.Active.getKey());
         accountMap.put(id, account);
         predictableResult = new AccountResult(new EnumMessage(BalanceError.AccountNotPresent));
@@ -130,5 +127,29 @@ class AccountBalanceServiceTest extends AbstractServiceTest {
         result = accountBalanceService.createAccountBalance(addresseeIdNew, accountIdNew, amountNew, cashMovementCurrencyCodeNew);
         ACCOUNT_BALANCE_MATCHER.assertMatch(result, predictableResult);
 
+        //AccountNotPresent id=null
+        account.setId(null);
+        account.setAccountType(AccountType.Clrn.getKey());
+        account.setAccountStatus(Status.Active.getKey());
+        accountMap.put(id, account);
+        predictableResult = new AccountResult(new EnumMessage(BalanceError.AccountNotPresent));
+
+        result = accountBalanceService.createAccountBalance(addresseeIdNew, accountIdNew, amountNew, cashMovementCurrencyCodeNew);
+        ACCOUNT_BALANCE_MATCHER.assertMatch(result, predictableResult);
+
+        //AccountNotActive accountStatus=null
+        account.setId(accountIdNew);
+        account.setAccountType(AccountType.Clrn.getKey());
+        account.setAccountStatus(null);
+        accountMap.put(id, account);
+        predictableResult = new AccountResult(new EnumMessage(BalanceError.AccountNotActive, account.getId()));
+
+        result = accountBalanceService.createAccountBalance(addresseeIdNew, accountIdNew, amountNew, cashMovementCurrencyCodeNew);
+        ACCOUNT_BALANCE_MATCHER.assertMatch(result, predictableResult);
+
+        account.setAccountStatus(Status.Active.getKey());
+        accountMap.put(id, account);
+        result = accountBalanceService.createAccountBalance(addresseeIdNew, null, amountNew, cashMovementCurrencyCodeNew);
+        ACCOUNT_BALANCE_MATCHER.assertMatch(result, predictableResult);
     }
 }

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/Sdf01ExecutorTest.java

@@ -0,0 +1,52 @@
+package ru.spcex.clearing.balance.service;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.sdf.SDf01;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.Status;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Collections;
+
+class Sdf01ExecutorTest extends AbstractServiceTest {
+
+    private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
+    @Autowired
+    Sdf01Executor sdf01Executor;
+    private final String deal = "111111111";
+    private final String acc = "123456789";
+    private final Long id = currentId.getAndIncrement();
+
+    @Test
+    void execute() {
+        SDf01 sDf01 = new SDf01();
+        sDf01.setMarket("U");//!"U".equals
+        sDf01.setDeal(deal);//tradingCode
+        sDf01.setAccount(acc);
+        sDf01.setCurr_code("RUR");
+        sDf01.setDat(LocalDate.now().format(datFormatter));
+        sDf01.setAcc_type("A");
+
+        Company company = new Company();
+        company.setTradingCode(deal);
+        companyMap.put(id, company);
+
+        Account account = new Account();
+        account.setId(id);
+        account.setAccount(acc);
+        account.setAccountType(AccountType.Clrn.getKey());
+        account.setAccountStatus(Status.Active.getKey());
+        accountMap.put(id, account);
+
+        StatementRequest statementRequest = new StatementRequest();
+
+        Result predictableResult = new Result();
+        predictableResult.setGenerationId(id);
+        Result result = sdf01Executor.execute(Collections.singletonList(sDf01), statementRequest);
+    }
+}

clearing-parent/reports-service/pom.xml

@@ -33,11 +33,23 @@
             <groupId>com.fasterxml.jackson.dataformat</groupId>
             <artifactId>jackson-dataformat-xml</artifactId>
         </dependency>
+
         <dependency>
             <groupId>com.thoughtworks.xstream</groupId>
             <artifactId>xstream</artifactId>
             <version>1.4.19</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+            <version>5.1.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

clearing-parent/reports-service/src/main/java/ru/spcex/clearing/reports/services/DOCXService.java

@@ -0,0 +1,90 @@
+package ru.spcex.clearing.reports.services;
+
+import org.apache.poi.xwpf.usermodel.*;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Сервис для работы с DOCX файлами
+ * Читает шаблон .docx и во всех текстовых элементах меняет переданные ключи на соответствующие им значения
+ */
+public class DOCXService {
+    /**
+     * При инициализации сохраняет все имеющиеся ключи (ищет по маске keyPattern), найденные в текстовых элементах документа
+     */
+    private final Map<String, TextPositionOnRun> bodyElementForKey = new HashMap<>();
+    private final Pattern KEY_PATTERN = Pattern.compile("\\$\\{.*?}");
+    private final int MAX_POSITION = 128;
+
+    /**
+     * Инициализация шаблона
+     *
+     * @param templateFile файл шаблона
+     */
+    public void init(File templateFile) throws IOException {
+        assert templateFile != null && templateFile.exists() && templateFile.isFile();
+        try (InputStream inputStream = new FileInputStream(templateFile)) {
+            XWPFDocument doc = new XWPFDocument(inputStream);
+
+            for (IBodyElement element : doc.getBodyElements()) {
+                if (element instanceof XWPFTable table) {
+                    collectKeysFromTable(table);
+                } else if (element instanceof XWPFParagraph paragraph) {
+                    collectKeysFromParagraph(paragraph);
+                }
+            }
+
+            System.out.println("hello");
+        }
+    }
+
+    private void collectKeysFromTable(XWPFTable srcTable) {
+        for (XWPFTableRow row : srcTable.getRows()) {
+            for (XWPFTableCell cell : row.getTableCells()) {
+                for (IBodyElement element : cell.getBodyElements()) {
+                    if (element instanceof XWPFTable table) {
+                        collectKeysFromTable(table);
+                    } else if (element instanceof XWPFParagraph paragraph) {
+                        collectKeysFromParagraph(paragraph);
+                    }
+                }
+            }
+        }
+    }
+
+    private void collectKeysFromParagraph(XWPFParagraph paragraph) {
+
+        for (XWPFRun run : paragraph.getRuns()) {
+            try {
+                for (int currPos = 0; currPos < MAX_POSITION; currPos++) {
+                    String currText = run.getText(currPos);
+                    if (currText == null) break;
+                    Matcher matcher = KEY_PATTERN.matcher(currText);
+                    while (matcher.find()) {
+                        String key = matcher.group();
+                        bodyElementForKey.put(key, new TextPositionOnRun(run, currPos));
+                    }
+                }
+            } catch (IndexOutOfBoundsException ignored) {
+                // can't get all max text position for XWPFRun
+            }
+        }
+    }
+
+    static class TextPositionOnRun {
+        XWPFRun run;
+        int pos;
+
+        public TextPositionOnRun(XWPFRun run, int pos) {
+            this.run = run;
+            this.pos = pos;
+        }
+    }
+}

clearing-parent/reports-service/src/test/java/ru/spcex/clearing/reports/services/DOCXServiceTest.java

@@ -0,0 +1,31 @@
+package ru.spcex.clearing.reports.services;
+
+import org.apache.poi.xwpf.usermodel.XWPFDocument;
+import org.junit.jupiter.api.Test;
+
+import java.io.*;
+
+class DOCXServiceTest {
+    @Test
+    public void testREC_ACTV() {
+        String inputFilename = "REC.ACTV_TEST.docx";
+        try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(inputFilename);
+             InputStream testStream = getClass().getClassLoader().getResourceAsStream("1.docx");
+             OutputStream outputStream = new FileOutputStream("test.docx")) {
+            XWPFDocument templateDoc = new XWPFDocument(inputStream);
+            XWPFDocument testDoc = new XWPFDocument(testStream);
+            testDoc.getParagraphs().get(6).getRuns().get(1).setText("========АОВЛДЫАОЫВЛДОАЛЫВДАОЫВЛДАОЫВ========");
+            testDoc.write(outputStream);
+            System.out.println("h");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void test() throws IOException {
+        DOCXService service = new DOCXService();
+        service.init(new File(getClass().getClassLoader().getResource("REC.ACTV_TEST.docx").getPath()));
+        System.out.println("p");
+    }
+}