Java

1
2

FROM camunda/camunda-bpm-platform:run-7.17.0
COPY production.yml /camunda/configuration/production.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

camunda.bpm:
  webapp:
    csrf:
      enable-same-site-cookie: true
      same-site-cookie-option: STRICT
    header-security:
      hsts-disabled: false
      content-security-policy-value: base-uri 'self';
        default-src 'self' 'unsafe-inline' 'unsafe-eval';
        img-src 'self' data:;
        block-all-mixed-content;
        form-action 'self';
        frame-ancestors 'none';
        object-src 'none';
        sandbox
        allow-forms
        allow-scripts
        allow-same-origin
        allow-popups
authorization:
    enabled: true
    user-id-claim: sub
    administratorGroupName: camunda-admin
    authorizationCheckRevokes: never
  generic-properties:
    properties:
      enable-password-policy: true
   admin-auth:
     enabled: true
     administrator-user-name: admin
     administrator-group-name: admins

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import java.util.Scanner;

public class Main {

  public static void main(String[] args) {

    ReportEngine reportEngine = new ReportEngine();
    Scanner scanner = new Scanner(System.in);


    while (true) {
      printMenu();

      int userInput = scanner.nextInt();
      if (userInput == 1) {
        System.out.println("Выполняется ко***** 1");

      } else if (userInput == 2) {
        System.out.println("Выполняется ко***** 2");

      } else if (userInput == 3) {
        System.out.println("Выполняется ко***** 3");
        reportEngine.check();
      } else if (userInput == 4) {
      System.out.println("Выполняется ко***** 4");
        System.out.println("Самый прибыльный товар " + reportEngine.getTopProduct());
        System.out.println(reportEngine.biggerExpense());
      } else if (userInput == 5) {
        System.out.println("Выполняется ко***** 5");
        System.out.println("Прибыль по каждому месяцу составляет: " + reportEngine.profit());
        System.out.println("Средний расход в год составляет: " + reportEngine.averageExpense());
        System.out.println("Средний доход в год составляет: " + reportEngine.averageIncome());
      } else if (userInput == 6) {
        System.out.println("Пока!");
        scanner.close();
        return;
      } else {
        System.out.println("Такой команды нет");
      }
    }
  }

  public static void printMenu() {
    System.out.println("1) Считать все месячные отчёты ");
    System.out.println("2) Считать годовой отчёт");
    System.out.println("3) Сверить отчёты");
    System.out.println("4) Вывести информацию обо всех месячных отчётах");
    System.out.println("5) Вывести информацию о годовом отчёте");
    System.out.println("6) Выход из приложения");
  }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;

public class FileReader {
  ArrayList<String> readFileContents(String fileName) {
    String path = "./resources/" + fileName;
    try {
      return new ArrayList<>(Files.readAllLines(Path.of(path)));
    } catch (IOException e) {
      System.out.println("Невозможно прочитать файл с отчётом. Возможно, файл отсутствует в нужной директории.");
      return new ArrayList<>();
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import java.util.ArrayList;

public class MonthlyReport {
  FileReader fileReader = new FileReader();
  public ArrayList<MonthTotalPerYear> monthTotalPerYears = new ArrayList<>();

  public MonthlyReport() {
    for (int i = 1; i <= 3; i++) {
      String paths = "m.20210" + i + ".csv";
      ArrayList<String> lines = fileReader.readFileContents(paths);
      String[] lineContents = lines.get(i).split("\n");
      for (int j = 1; j < lineContents.length; j++) {
        String line = lineContents[j]; //Коньки,TRUE,2,2000
        String[] parts = line.split(",");
        String name = parts[0];
        boolean is_expense = Boolean.parseBoolean(parts[1]);
        int quantity = Integer.parseInt(parts[2]);
        int price = Integer.parseInt(parts[3]);

        MonthTotalPerYear monthTotalPerYear = new MonthTotalPerYear(name, is_expense, quantity, price);
        monthTotalPerYears.add(monthTotalPerYear);

      }
    }

  }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class MonthTotalPerYear {
  public String name;
  public boolean is_expense;
  public int quantity;
  public int price;

  public MonthTotalPerYear(String name, boolean is_expense, int quantity, int price) {
    this.name = name;
    this.is_expense = is_expense;
    this.quantity = quantity;
    this.price = price;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.ArrayList;

public class YearlyReport {
  public ArrayList<Transaction> transactions = new ArrayList<>();
  FileReader fileReader = new FileReader();

  public YearlyReport() {
    ArrayList<String> lines = fileReader.readFileContents("y.2021.csv");
    for (int i = 1; i < lines.size(); i++){
      String[] lineContents = lines.get(i).split("\n");
      for (int j = 1; j < lineContents.length; j++) {
        String line = lineContents[j]; //01,1593150,false
        String[] parts = line.split(",");
        String month = parts[0];
        int amount = Integer.parseInt(parts[1]);
        boolean isExpense = Boolean.parseBoolean(parts[2]);

        Transaction transaction = new Transaction(month, amount, isExpense);
        transactions.add(transaction);
      }
    }


  }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Transaction {

  public String month;
  public int amount;
  public boolean isExpense;

  public Transaction(String month, int amount, boolean isExpense) {
    this.month = month;
    this.amount = amount;
    this.isExpense = isExpense;
  }


}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

import java.util.ArrayList;
import java.util.HashMap;

public class ReportEngine {
  public MonthlyReport monthlyReport;
  public YearlyReport yearlyReport;

  public ReportEngine() {
    monthlyReport = new MonthlyReport();
    yearlyReport = new YearlyReport();
  }

  public String getTopProduct() {
    HashMap<String, Integer> fregs = new HashMap<>();
    for (MonthTotalPerYear monthTotalPerYear : monthlyReport.monthTotalPerYears) {
      fregs.put(monthTotalPerYear.name, fregs.getOrDefault(monthTotalPerYear.name, 0) + monthTotalPerYear.quantity);
    }
    String maxName = null;
    for (String name : fregs.keySet()) {
      if (maxName == null) {
        maxName = name;
        continue;
      }
      if (fregs.get(maxName) < fregs.get(name)) {
        maxName = name;
      }
    }
    return maxName;
  }

  public String biggerExpense() {
    HashMap<String, Integer> expense = new HashMap<>();
    for (MonthTotalPerYear monthTotalPerYear : monthlyReport.monthTotalPerYears) {
      if (monthTotalPerYear.is_expense) {
        expense.put(monthTotalPerYear.name, monthTotalPerYear.price);
      }
    }
    String nameExpense = null;
    for (String name : expense.keySet()) {
      if (nameExpense == null) {
        nameExpense = name;
        continue;
      }
      if (expense.get(nameExpense) < expense.get(name)) {
        nameExpense = name;
      }
    }
    System.out.println("Самая большая сумма траты - " + expense.get(nameExpense));
    return nameExpense;
  }

  public HashMap<String, Integer> profit() {
    HashMap<String, Integer> product = new HashMap<>();
    for (Transaction transaction : yearlyReport.transactions) {
      if (!(transaction.isExpense)) {
        product.put(transaction.month, transaction.amount);
      }
    }
    String maxTransaction = null;
    for (String name : product.keySet()) {
      if (maxTransaction == null) {
        maxTransaction = name;
        continue;
      }
      if (product.get(maxTransaction) < product.get(name)) {
        maxTransaction = name;
      }
    }
    return product;
  }

  public Integer averageIncome() {
    HashMap<String, Integer> product = new HashMap<>();
    for (Transaction transaction : yearlyReport.transactions) {
      if (!(transaction.isExpense)) {
        product.put(transaction.month, transaction.amount);
      }
    }
    Integer result = null;
    for (Integer sum : product.values()) {
      result += sum;
    }
    return result;
  }

  public Integer averageExpense() {
    HashMap<String, Integer> product = new HashMap<>();
    for (Transaction transaction : yearlyReport.transactions) {
      if (transaction.isExpense) {
        product.put(transaction.month, transaction.amount);
      }
    }
    Integer result = null;
    for (Integer sum : product.values()) {
      result += sum;
    }
    return result;
  }


  public boolean check() {
    if (monthlyReport.monthTotalPerYears.isEmpty()) {
      System.out.println("Ошибка! Для начала необходимо считать файлы! :)");
      return false;
    /* } else {

      if ((sum_income == sum_incomeYear) && (sum_expense == sum_expenseYear)){
        System.out.println("Успех! Сверка отчётов прошла успешно!");
      } else {
        System.out.println("Ошибка! Сверка отчётов обнаружела несоответствие в ");
      }
    }*/

    }
    return false;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

package io.hexlet;


import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static io.hexlet.implementations.Methods.fill;


import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;


class MethodsTest {
    private List<String> coll = new ArrayList<>();
    private List<String> emptyColl = new ArrayList<>();


    @BeforeEach
    public void beforeEach() {
        coll.addAll(Arrays.asList("a", "b", "c", "d"));
    }
    @Test
    public void testFill() {
        fill(coll, "*", 1, 3);
        assertEquals(Arrays.asList("a", "*", "*", "d"), coll);
    }
    @Test
    public void testFill1() {
        fill(coll, "*");
        assertEquals(Arrays.asList("*", "*", "*", "*"), coll);
    }
    @Test
    public void testFill2() {
        fill(coll, "*", 4, 6);
        assertEquals(Arrays.asList("a", "b", "c", "d"), coll);
    }
    @Test
    public void testFill3() {
        fill(coll, "*", 0, 10);
        assertEquals(Arrays.asList("*", "*", "*", "*"), coll);
    }
    @Test
    public void testFill4() {
        fill(coll, "*", 2);
        assertEquals(Arrays.asList("a", "b", "*", "*"), coll);
    }
    @Test
    public void testFill5() {
        fill(coll, "*", -1, 4);
        assertEquals(Arrays.asList("*", "*", "*", "*"), coll);
    }
    @Test
    public void testFill6() {
        fill(emptyColl, "*");
        assertEquals(Arrays.asList(), emptyColl);
    }
    @Test
    public void testFill7() {
        fill(coll, "*", 5, 6);
        assertEquals(Arrays.asList("a", "b", "c", "d"), coll);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

Failures (1):
  JUnit Jupiter:TestsTest:testRightImplementation()
    MethodSource [className = 'io.hexlet.TestsTest', methodName = 'testRightImplementation', methodParameterTypes = '']
    => org.opentest4j.AssertionFailedError: [The tests should have passed, but they failed] 
Expecting value to be true but was false
       java.base/jdk.internal.reflect.DirectConstructorHandleAccessor.newInstance(DirectConstructorHandleAccessor.java:62)
       java.base/java.lang.reflect.Constructor.newInstanceWithCaller(Constructor.java:502)
       io.hexlet.TestsTest.testRightImplementation(TestsTest.java:44)
       java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
       java.base/java.lang.reflect.Method.invoke(Method.java:580)
       org.junit.platform.commons.util.ReflectionUtils.invokeMethod(ReflectionUtils.java:727)
       org.junit.jupiter.engine.execution.MethodInvocation.proceed(MethodInvocation.java:60)
       org.junit.jupiter.engine.execution.InvocationInterceptorChain$ValidatingInvocation.proceed(InvocationInterceptorChain.java:131)
       org.junit.jupiter.engine.extension.TimeoutExtension.intercept(TimeoutExtension.java:156)
       org.junit.jupiter.engine.extension.TimeoutExtension.interceptTestableMethod(TimeoutExtension.java:147)
       [...]