From 7dc50bf0adef594b8666dd86319e106cc1e6165f Mon Sep 17 00:00:00 2001 From: riknel Date: Mon, 19 Dec 2016 17:18:55 +0300 Subject: [PATCH 01/10] First commit with REST and Calculator. --- homework-g597-kirilenko/pom.xml | 36 +++ .../g597/kirilenko/task1/MyCalculator.java | 297 +++++++++++++++++- .../g597/kirilenko/task4/BillingDao.java | 57 ++++ .../task4/BillingDatabaseConfiguration.java | 26 ++ .../g597/kirilenko/task4/BillingUser.java | 69 ++++ .../kirilenko/task4/CalculatorController.java | 85 +++++ .../kirilenko/task4/MySpringApplication.java | 37 +++ .../task4/SecurityServiceConfiguration.java | 55 ++++ .../homework/g597/kirilenko/task4/tests.txt | 18 ++ 9 files changed, 678 insertions(+), 2 deletions(-) create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java create mode 100644 homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt diff --git a/homework-g597-kirilenko/pom.xml b/homework-g597-kirilenko/pom.xml index 481d50ef5..f091bb3a0 100644 --- a/homework-g597-kirilenko/pom.xml +++ b/homework-g597-kirilenko/pom.xml @@ -9,6 +9,10 @@ 4.0.0 + + 1.4.2.RELEASE + + homework-g597-kirilenko @@ -24,6 +28,38 @@ 1.0.0 test + + net.sourceforge.jeval + jeval + 0.9.4 + + + + org.springframework.boot + spring-boot-starter-web + ${spring.boot.version} + + + org.springframework.boot + spring-boot-starter-jdbc + ${spring.boot.version} + + + org.springframework.boot + spring-boot-starter-security + ${spring.boot.version} + + + com.zaxxer + HikariCP + 2.5.1 + + + com.h2database + h2 + 1.4.193 + + com.google.guava guava diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java index 2e0e4c5e9..d6975c8ff 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java @@ -1,15 +1,309 @@ package ru.mipt.java2016.homework.g597.kirilenko.task1; + + +import javafx.util.Pair; import ru.mipt.java2016.homework.base.task1.Calculator; import ru.mipt.java2016.homework.base.task1.ParsingException; -import java.util.Stack; +import java.util.*; + +import static java.lang.Math.*; public class MyCalculator implements Calculator { private Stack numbers; private Stack operations; + private final Map variablesExpressions = new HashMap(); + private final Map, String>> functions = new HashMap(); + + private double calculateStandardExpression(String functionName, ArrayList arguments) throws ParsingException { + if (functionName.equals("sin")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return sin(arguments.get(0)); + } + if (functionName.equals("cos")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return cos(arguments.get(0)); + } + if (functionName.equals("tg")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return tan(arguments.get(0)); + } + if (functionName.equals("sqrt")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return sqrt(arguments.get(0)); + } + if(functionName.equals("abs")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return abs(arguments.get(0)); + } + if(functionName.equals("max")) { + if(arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return max(arguments.get(0), arguments.get(1)); + } + if(functionName.equals("min")) { + if(arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return min(arguments.get(0), arguments.get(1)); + } + if(functionName.equals("pow")) { + if(arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return pow(arguments.get(0), arguments.get(1)); + } + if(functionName.equals("log")) { + if(arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return log(arguments.get(0)) / log(arguments.get(1)); + } + if(functionName.equals("log2")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return log(arguments.get(0)) / log(2); + } + if(functionName.equals("rnd")) { + if(arguments.size() != 0) { + throw new ParsingException("Incorrect expression"); + } + return random(); + } + if(functionName.equals("sign")) { + if(arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return signum(arguments.get(0)); + } + throw new ParsingException("Not standard expression."); + } + + private boolean isStandardFunction(String functionName) { + return functionName.equals("sin") || + functionName.equals("cos") || + functionName.equals("tg") || + functionName.equals("sqrt") || + functionName.equals("pow") || + functionName.equals("abs") || + functionName.equals("sign") || + functionName.equals("log") || + functionName.equals("log2") || + functionName.equals("rnd") || + functionName.equals("max")|| + functionName.equals("min"); + + } + + public String getVariableExpression(String variable) { + if (!variablesExpressions.keySet().contains(variable)) { + return null; + } + return variablesExpressions.get(variable); + } + + public void setVariableExpression(String variable, String expression) { + variablesExpressions.put(variable, expression); + } + + public void deleteVariable(String variable) { + variablesExpressions.remove(variable); + } + + public ArrayList getAllVariables() { + return new ArrayList<>(variablesExpressions.keySet()); + } + + public Pair, String> getFunctionInfo(String functionName) { + return functions.get(functionName); + } + + public boolean setFunction(String functionName, ArrayList arguments, String expression) { + if (isStandardFunction(functionName)) { + return false; + } + functions.put(functionName, new Pair<>(arguments, expression)); + return true; + } + + public boolean deleteFunction(String functionName) { + if (isStandardFunction(functionName)) { + return false; + } + functions.remove(functionName); + return true; + } + + public ArrayList getAllFunctions() { + return new ArrayList<>(functions.keySet()); + } + + private boolean isDigit(char c) { + return (c >= '0' && c <= '9'); + } + + private boolean isLatinSymbol(char c) { + return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); + } + + private boolean isUnderscore(char c) { + return c == '_'; + } + + private boolean isOpeningBracket(char c) { + return c == '('; + } + + + private Pair getValueLexem(String expression, Integer startIndex) { + Integer firstIndex = startIndex; + while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && !isLatinSymbol(expression.charAt(firstIndex))) { + firstIndex += 1; + } + if (firstIndex >= expression.length()) { + return null; + } + Integer secondIndex = firstIndex; + while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { + secondIndex += 1; + } + if (secondIndex == expression.length() || expression.charAt(secondIndex) != '(') { + return new Pair<>(firstIndex, secondIndex); + } else { + return getValueLexem(expression, secondIndex + 1); + } + } + + private Pair>, ArrayList> getFunctionLexem(String expression) { + Integer firstIndex = 0; + while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && !isLatinSymbol(expression.charAt(firstIndex))) { + firstIndex += 1; + } + if (firstIndex >= expression.length()) { + return null; + } + Integer secondIndex = firstIndex; + while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { + secondIndex += 1; + } + String name = expression.substring(firstIndex, secondIndex); + Pair, Integer> arg = getArguments(expression, secondIndex); + ArrayList arguments = arg.getKey(); + Integer lastIndex = arg.getValue(); + Pair indices = new Pair<>(firstIndex, lastIndex); + return new Pair<>(new Pair<>(name, indices), arguments); + } + + private Pair, Integer> getArguments(String expression, Integer startIndex) { + ArrayList arguments = new ArrayList<>(); + Integer lastIndex = 0; + Integer balance = 1; + Integer currentIndex = startIndex + 1; + String currentArgument = ""; + while(balance != 0) { //выражение уже проверено на корректность -> exception не выбрасываем + if (expression.charAt(currentIndex) == '(') { + balance += 1; + currentArgument += expression.charAt(currentIndex); + currentIndex++; + } else if (expression.charAt(currentIndex) == ')') { + balance -= 1; + currentArgument += expression.charAt(currentIndex); + currentIndex++; + } else if (balance == 1 && expression.charAt(currentIndex) == ',') { + arguments.add(currentArgument); + currentArgument = ""; + currentIndex++; + } else { + currentArgument += expression.charAt(currentIndex); + currentIndex++; + } + } + arguments.add(currentArgument.substring(0, currentArgument.length() - 1)); + return new Pair<>(arguments, currentIndex); + } + + private Pair findArgument(String expression, String argument) { + int lastIndex = expression.indexOf(argument, 0); + if (lastIndex == -1) { + return null; + } + return new Pair<>(lastIndex, lastIndex + argument.length()); + } + + private Double evaluateFunction(String expression, ArrayList argumentsList, ArrayList arguments) throws ParsingException { + for (int i = 0; i < argumentsList.size(); i++) { + String argument = argumentsList.get(i); + Pair argCoord = findArgument(expression, argument); + while (argCoord != null) { + expression = expression.substring(0, argCoord.getKey()) + arguments.get(i).toString() + expression.substring(argCoord.getValue(), expression.length()); + argCoord = findArgument(expression, argument); + } + } + try { + return evaluateExpression(expression); + } catch (ParsingException e) { + throw e; + } + } + + + + public double evaluateExpression(String expression) throws ParsingException { + expression = deleteSpaces(expression); + + + try { + Pair valueLexem = getValueLexem(expression, 0); + while (valueLexem != null) { + Integer start = valueLexem.getKey(); + Integer end = valueLexem.getValue(); + String valueName = expression.substring(start, end); + String valExpr = getVariableExpression(valueName); + Double result = evaluateExpression(valExpr); + expression = expression.substring(0, start) + result.toString() + expression.substring(end, expression.length()); + valueLexem = getValueLexem(expression, 0); + } + Pair>, ArrayList> functionLexem = getFunctionLexem(expression); + while (functionLexem != null) { + String functionName = functionLexem.getKey().getKey(); + Integer start = functionLexem.getKey().getValue().getKey(); + Integer end = functionLexem.getKey().getValue().getValue(); + ArrayList arguments = functionLexem.getValue(); + ArrayList calculatedArguments = new ArrayList<>(); + for (int i = 0; i < arguments.size(); i++) { + calculatedArguments.add(evaluateExpression(arguments.get(i))); + } + Double result = Double.NaN; + if (isStandardFunction(functionName)) { + result = calculateStandardExpression(functionName, calculatedArguments); + } else { + Pair, String> func = getFunctionInfo(functionName); + result = evaluateFunction(func.getValue(), func.getKey(), calculatedArguments); + } + expression = expression.substring(0, start) + result.toString() + expression.substring(end, expression.length()); + functionLexem = getFunctionLexem(expression); + } + return calculate(expression); + } catch (ParsingException p) { + throw p; + } + } + @Override public double calculate(String expression) throws ParsingException { numbers = new Stack<>(); @@ -21,7 +315,6 @@ public double calculate(String expression) throws ParsingException { if (!checkForConsequentNumbers(expression)) { throw new ParsingException("Incorrect expression"); } - expression = deleteSpaces(expression); if (!checkIncorrectExpression(expression)) { throw new ParsingException("Incorrect expression"); } diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java new file mode 100644 index 000000000..73c37b5a3 --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java @@ -0,0 +1,57 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.dao.EmptyResultDataAccessException; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.core.RowMapper; +import org.springframework.stereotype.Repository; + +import javax.annotation.PostConstruct; +import javax.sql.DataSource; +import java.sql.ResultSet; +import java.sql.SQLException; + +@Repository +public class BillingDao { + private static final Logger LOG = LoggerFactory.getLogger(BillingDao.class); + + @Autowired + private DataSource dataSource; + + private JdbcTemplate jdbcTemplate; + + @PostConstruct + public void postConstruct() { + jdbcTemplate = new JdbcTemplate(dataSource, false); + initSchema(); + } + + public void initSchema() { + LOG.trace("Initializing schema"); + jdbcTemplate.execute("CREATE SCHEMA IF NOT EXISTS billing"); + jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.users " + + "(username VARCHAR PRIMARY KEY, password VARCHAR, enabled BOOLEAN)"); + jdbcTemplate.update("INSERT INTO billing.users VALUES ('username', 'password', TRUE)"); + } + + + public BillingUser loadUser(String username) throws EmptyResultDataAccessException { + LOG.trace("Querying for user " + username); + return jdbcTemplate.queryForObject( + "SELECT username, password, enabled FROM billing.users WHERE username = ?", + new Object[]{username}, + new RowMapper() { + @Override + public BillingUser mapRow(ResultSet rs, int rowNum) throws SQLException { + return new BillingUser( + rs.getString("username"), + rs.getString("password"), + rs.getBoolean("enabled") + ); + } + } + ); + } +} diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java new file mode 100644 index 000000000..a85926517 --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java @@ -0,0 +1,26 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + +import com.zaxxer.hikari.HikariConfig; +import com.zaxxer.hikari.HikariDataSource; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +import javax.sql.DataSource; + +@Configuration +public class BillingDatabaseConfiguration { + @Bean + public DataSource billingDataSource( + @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.jdbcUrl}") String jdbcUrl, + @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.username:}") String username, + @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.password:}") String password + ) { + HikariConfig config = new HikariConfig(); + config.setDriverClassName(org.h2.Driver.class.getName()); + config.setJdbcUrl(jdbcUrl); + config.setUsername(username); + config.setPassword(password); + return new HikariDataSource(config); + } +} diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java new file mode 100644 index 000000000..786f3e767 --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java @@ -0,0 +1,69 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + +public class BillingUser { + private final String username; + private final String password; + private final boolean enabled; + + public BillingUser(String username, String password, boolean enabled) { + if (username == null) { + throw new IllegalArgumentException("Null username is not allowed"); + } + if (password == null) { + throw new IllegalArgumentException("Null password is not allowed"); + } + this.username = username; + this.password = password; + this.enabled = enabled; + } + + public String getUsername() { + return username; + } + + public String getPassword() { + return password; + } + + public boolean isEnabled() { + return enabled; + } + + @Override + public String toString() { + return "BillingUser{" + + "username='" + username + '\'' + + ", password='" + password + '\'' + + ", enabled=" + enabled + + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + BillingUser that = (BillingUser) o; + + if (enabled != that.enabled) { + return false; + } + if (!username.equals(that.username)) { + return false; + } + return password.equals(that.password); + + } + + @Override + public int hashCode() { + int result = username.hashCode(); + result = 31 * result + password.hashCode(); + result = 31 * result + (enabled ? 1 : 0); + return result; + } +} diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java new file mode 100644 index 000000000..158a0af02 --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -0,0 +1,85 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + +import javafx.util.Pair; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import ru.mipt.java2016.homework.base.task1.ParsingException; +import ru.mipt.java2016.homework.g597.kirilenko.task1.MyCalculator; + +import java.util.ArrayList; +import java.util.List; + +@RestController +public class CalculatorController { + private static final Logger LOG = LoggerFactory.getLogger(CalculatorController.class); + @Autowired + private MyCalculator calculator; + + + @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.GET) + public @ResponseBody String getVariable(@PathVariable String variableName) { + String result = calculator.getVariableExpression(variableName); + return result; + } + + @RequestMapping(path = "/function/{functionName}", method = RequestMethod.GET) + public @ResponseBody String getFunction(@PathVariable String functionName) { + Pair, String> info = calculator.getFunctionInfo(functionName); + String result = info.getValue() + "&"; + for (int i = 0; i < info.getKey().size(); i++) { + result += info.getKey().get(i); + if (i != info.getKey().size()-1) { + result += ","; + } + } + return result; + } + + @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.PUT, + consumes = "text/plain", produces = "text/plain") + public @ResponseBody void putVariable(@PathVariable String variableName, + @RequestBody String expr) throws ParsingException { + calculator.setVariableExpression(variableName, expr); + } + + @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.DELETE) + public void deleteVariable(@PathVariable String variableName) { + calculator.deleteVariable(variableName); + } + + @RequestMapping(path = "/variable", method = RequestMethod.GET) + public @ResponseBody ArrayList getVariables() { + return calculator.getAllVariables(); + } + + + @RequestMapping(path = "/function/{functionName}", method = RequestMethod.PUT) + public @ResponseBody void putFunction(@PathVariable String functionName, + @RequestParam(value = "args") ArrayList args, + @RequestBody String functionBody) throws ParsingException { + calculator.setFunction(functionName, new ArrayList<>(args), functionBody); + } + + @RequestMapping(path = "/function/{functionName}", method = RequestMethod.DELETE) + public @ResponseBody Boolean deleteFunction(@PathVariable String functionName) { + return calculator.deleteFunction(functionName); + } + + @RequestMapping(path = "/function", method = RequestMethod.GET) + public @ResponseBody ArrayList getFunctionsNames() { + return calculator.getAllFunctions(); + } + + @RequestMapping(path = "/ping", method = RequestMethod.GET, produces = "text/plain") + public String echo() { + return "OK\n"; + } + + @RequestMapping(path = "/eval", method = RequestMethod.POST, consumes = "text/plain", produces = "text/plain") + public @ResponseBody String eval(@RequestBody String expression) throws ParsingException { + double result = calculator.evaluateExpression(expression); + return Double.toString(result) + "\n"; + } +} diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java new file mode 100644 index 000000000..dac952ec6 --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java @@ -0,0 +1,37 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.Banner; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; + +import ru.mipt.java2016.homework.g597.kirilenko.task1.MyCalculator; + +//curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "44*3+2" + +@EnableAutoConfiguration +@Configuration +@ComponentScan(basePackageClasses = MySpringApplication.class) +public class MySpringApplication { + + @Bean + public MyCalculator calculator() { + return new MyCalculator(); + } + + @Bean + public EmbeddedServletContainerCustomizer customizer( + @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.httpPort:9001}") int port) { + return container -> container.setPort(port); + } + + public static void main(String[] args) { + SpringApplication application = new SpringApplication(MySpringApplication.class); + application.setBannerMode(Banner.Mode.OFF); + application.run(args); + } +} diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java new file mode 100644 index 000000000..5796f4586 --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java @@ -0,0 +1,55 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Configuration; +import org.springframework.dao.EmptyResultDataAccessException; +import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; +import org.springframework.security.config.annotation.web.builders.HttpSecurity; +import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; +import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; +import org.springframework.security.core.userdetails.User; +import org.springframework.security.core.userdetails.UsernameNotFoundException; + +import java.util.Collections; + +@Configuration +@EnableWebSecurity +public class SecurityServiceConfiguration extends WebSecurityConfigurerAdapter { + private static final Logger LOG = LoggerFactory.getLogger(SecurityServiceConfiguration.class); + + @Autowired + private BillingDao billingDao; + + @Override + protected void configure(HttpSecurity http) throws Exception { + LOG.info("Configuring security"); + http + .httpBasic().realmName("Calculator").and() + .formLogin().disable() + .logout().disable() + .csrf().disable() + .authorizeRequests() + .antMatchers("/eval/**").authenticated() + .anyRequest().permitAll(); + } + + @Autowired + public void registerGlobalAuthentication(AuthenticationManagerBuilder auth) throws Exception { + LOG.info("Registering global user details service"); + auth.userDetailsService(username -> { + try { + BillingUser user = billingDao.loadUser(username); + return new User( + user.getUsername(), + user.getPassword(), + Collections.singletonList(() -> "AUTH") + ); + } catch (EmptyResultDataAccessException e) { + LOG.warn("No such user: " + username); + throw new UsernameNotFoundException(username); + } + }); + } +} diff --git a/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt b/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt new file mode 100644 index 000000000..3c05d7b37 --- /dev/null +++ b/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt @@ -0,0 +1,18 @@ +// Вводим функции myfunc1, su2 +curl http://localhost:9001/function/myfunc1?args=x,y -X PUT -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "log2(x) + y" +curl http://localhost:9001/function/sum2?args=x,y -X PUT -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "x+2* y" + +curl http://localhost:9001/variable/xy -X PUT -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "sqrt(9)+sign(2)" +curl http://localhost:9001/variable/_2xy -X PUT -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "log2(xy*sign(xy)) *2" + +curl http://localhost:9001/function/myfunc1 -X GET -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" +curl http://localhost:9001/function/sum2 -X GET -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" + +curl http://localhost:9001/function -X GET -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" +curl http://localhost:9001/variable -X GET -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" + +// Маленький +curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "_2xy" + +// Большой тест +curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "sum2(myfunc1(xy, _2xy), sum2(4, sqrt(16)))*cos(0)" \ No newline at end of file From 73cd273ee1bbba1c21c1f25ed80be550dd5630fa Mon Sep 17 00:00:00 2001 From: riknel Date: Mon, 19 Dec 2016 17:41:22 +0300 Subject: [PATCH 02/10] Small bugfixes. --- .../homework/g597/kirilenko/task4/CalculatorController.java | 3 +-- .../mipt/java2016/homework/g597/kirilenko/task4/tests.txt | 6 +++--- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java index 158a0af02..a7775c337 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -9,7 +9,6 @@ import ru.mipt.java2016.homework.g597.kirilenko.task1.MyCalculator; import java.util.ArrayList; -import java.util.List; @RestController public class CalculatorController { @@ -34,7 +33,7 @@ public class CalculatorController { result += ","; } } - return result; + return result + "\n"; } @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.PUT, diff --git a/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt b/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt index 3c05d7b37..c2107ab3f 100644 --- a/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt +++ b/homework-g597-kirilenko/src/test/java/ru/mipt/java2016/homework/g597/kirilenko/task4/tests.txt @@ -1,4 +1,4 @@ -// Вводим функции myfunc1, su2 + curl http://localhost:9001/function/myfunc1?args=x,y -X PUT -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "log2(x) + y" curl http://localhost:9001/function/sum2?args=x,y -X PUT -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "x+2* y" @@ -12,7 +12,7 @@ curl http://localhost:9001/function -X GET -H "Content-Type: text/plain" -H "Aut curl http://localhost:9001/variable -X GET -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" // Маленький -curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "_2xy" +curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "sqrt(_2xy*sqrt(16)) - sin(0)" // Большой тест -curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "sum2(myfunc1(xy, _2xy), sum2(4, sqrt(16)))*cos(0)" \ No newline at end of file +curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "(sum2(myfunc1(xy, _2xy), sum2(4, sqrt(16)))*cos(0)" \ No newline at end of file From fd2b199aad08c3dbd69ca0def8c47dbcecb387f1 Mon Sep 17 00:00:00 2001 From: riknel Date: Mon, 19 Dec 2016 17:52:18 +0300 Subject: [PATCH 03/10] Checkstyle fixes. --- .../g597/kirilenko/task1/MyCalculator.java | 76 +++++++++++-------- .../kirilenko/task4/CalculatorController.java | 6 +- 2 files changed, 46 insertions(+), 36 deletions(-) diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java index d6975c8ff..f1477dd7f 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java @@ -18,75 +18,76 @@ public class MyCalculator implements Calculator { private final Map variablesExpressions = new HashMap(); private final Map, String>> functions = new HashMap(); - private double calculateStandardExpression(String functionName, ArrayList arguments) throws ParsingException { + private double calculateStandardExpression(String functionName, ArrayList arguments) + throws ParsingException { if (functionName.equals("sin")) { - if(arguments.size() != 1) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return sin(arguments.get(0)); } if (functionName.equals("cos")) { - if(arguments.size() != 1) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return cos(arguments.get(0)); } if (functionName.equals("tg")) { - if(arguments.size() != 1) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return tan(arguments.get(0)); } if (functionName.equals("sqrt")) { - if(arguments.size() != 1) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return sqrt(arguments.get(0)); } - if(functionName.equals("abs")) { - if(arguments.size() != 1) { + if (functionName.equals("abs")) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return abs(arguments.get(0)); } - if(functionName.equals("max")) { - if(arguments.size() != 2) { + if (functionName.equals("max")) { + if (arguments.size() != 2) { throw new ParsingException("Incorrect expression"); } return max(arguments.get(0), arguments.get(1)); } - if(functionName.equals("min")) { - if(arguments.size() != 2) { + if (functionName.equals("min")) { + if (arguments.size() != 2) { throw new ParsingException("Incorrect expression"); } return min(arguments.get(0), arguments.get(1)); } - if(functionName.equals("pow")) { - if(arguments.size() != 2) { + if (functionName.equals("pow")) { + if (arguments.size() != 2) { throw new ParsingException("Incorrect expression"); } return pow(arguments.get(0), arguments.get(1)); } - if(functionName.equals("log")) { - if(arguments.size() != 2) { + if (functionName.equals("log")) { + if (arguments.size() != 2) { throw new ParsingException("Incorrect expression"); } return log(arguments.get(0)) / log(arguments.get(1)); } - if(functionName.equals("log2")) { - if(arguments.size() != 1) { + if (functionName.equals("log2")) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return log(arguments.get(0)) / log(2); } - if(functionName.equals("rnd")) { - if(arguments.size() != 0) { + if (functionName.equals("rnd")) { + if (arguments.size() != 0) { throw new ParsingException("Incorrect expression"); } return random(); } - if(functionName.equals("sign")) { - if(arguments.size() != 1) { + if (functionName.equals("sign")) { + if (arguments.size() != 1) { throw new ParsingException("Incorrect expression"); } return signum(arguments.get(0)); @@ -105,7 +106,7 @@ private boolean isStandardFunction(String functionName) { functionName.equals("log") || functionName.equals("log2") || functionName.equals("rnd") || - functionName.equals("max")|| + functionName.equals("max") || functionName.equals("min"); } @@ -172,14 +173,16 @@ private boolean isOpeningBracket(char c) { private Pair getValueLexem(String expression, Integer startIndex) { Integer firstIndex = startIndex; - while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && !isLatinSymbol(expression.charAt(firstIndex))) { + while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && + !isLatinSymbol(expression.charAt(firstIndex))) { firstIndex += 1; } if (firstIndex >= expression.length()) { return null; } Integer secondIndex = firstIndex; - while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { + while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || + isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { secondIndex += 1; } if (secondIndex == expression.length() || expression.charAt(secondIndex) != '(') { @@ -189,16 +192,18 @@ private Pair getValueLexem(String expression, Integer startInd } } - private Pair>, ArrayList> getFunctionLexem(String expression) { + private Pair>, ArrayList> getFunctionLexem(String expression) { Integer firstIndex = 0; - while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && !isLatinSymbol(expression.charAt(firstIndex))) { + while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && + !isLatinSymbol(expression.charAt(firstIndex))) { firstIndex += 1; } if (firstIndex >= expression.length()) { return null; } Integer secondIndex = firstIndex; - while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { + while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || + isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { secondIndex += 1; } String name = expression.substring(firstIndex, secondIndex); @@ -215,7 +220,7 @@ private Pair, Integer> getArguments(String expression, Integer Integer balance = 1; Integer currentIndex = startIndex + 1; String currentArgument = ""; - while(balance != 0) { //выражение уже проверено на корректность -> exception не выбрасываем + while (balance != 0) { //выражение уже проверено на корректность -> exception не выбрасываем if (expression.charAt(currentIndex) == '(') { balance += 1; currentArgument += expression.charAt(currentIndex); @@ -245,12 +250,14 @@ private Pair findArgument(String expression, String argument) return new Pair<>(lastIndex, lastIndex + argument.length()); } - private Double evaluateFunction(String expression, ArrayList argumentsList, ArrayList arguments) throws ParsingException { + private Double evaluateFunction(String expression, ArrayList argumentsList, + ArrayList arguments) throws ParsingException { for (int i = 0; i < argumentsList.size(); i++) { String argument = argumentsList.get(i); Pair argCoord = findArgument(expression, argument); while (argCoord != null) { - expression = expression.substring(0, argCoord.getKey()) + arguments.get(i).toString() + expression.substring(argCoord.getValue(), expression.length()); + expression = expression.substring(0, argCoord.getKey()) + arguments.get(i).toString() + + expression.substring(argCoord.getValue(), expression.length()); argCoord = findArgument(expression, argument); } } @@ -275,10 +282,12 @@ public double evaluateExpression(String expression) throws ParsingException { String valueName = expression.substring(start, end); String valExpr = getVariableExpression(valueName); Double result = evaluateExpression(valExpr); - expression = expression.substring(0, start) + result.toString() + expression.substring(end, expression.length()); + expression = expression.substring(0, start) + result.toString() + + expression.substring(end, expression.length()); valueLexem = getValueLexem(expression, 0); } - Pair>, ArrayList> functionLexem = getFunctionLexem(expression); + Pair>, ArrayList> functionLexem = + getFunctionLexem(expression); while (functionLexem != null) { String functionName = functionLexem.getKey().getKey(); Integer start = functionLexem.getKey().getValue().getKey(); @@ -295,7 +304,8 @@ public double evaluateExpression(String expression) throws ParsingException { Pair, String> func = getFunctionInfo(functionName); result = evaluateFunction(func.getValue(), func.getKey(), calculatedArguments); } - expression = expression.substring(0, start) + result.toString() + expression.substring(end, expression.length()); + expression = expression.substring(0, start) + result.toString() + + expression.substring(end, expression.length()); functionLexem = getFunctionLexem(expression); } return calculate(expression); diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java index a7775c337..c4b1cd3b4 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -45,7 +45,7 @@ public class CalculatorController { @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.DELETE) public void deleteVariable(@PathVariable String variableName) { - calculator.deleteVariable(variableName); + calculator.deleteVariable(variableName); } @RequestMapping(path = "/variable", method = RequestMethod.GET) @@ -56,8 +56,8 @@ public void deleteVariable(@PathVariable String variableName) { @RequestMapping(path = "/function/{functionName}", method = RequestMethod.PUT) public @ResponseBody void putFunction(@PathVariable String functionName, - @RequestParam(value = "args") ArrayList args, - @RequestBody String functionBody) throws ParsingException { + @RequestParam(value = "args") ArrayList args, + @RequestBody String functionBody) throws ParsingException { calculator.setFunction(functionName, new ArrayList<>(args), functionBody); } From 56bcdcc3ecd416741031d5b8b5ef77824752bcc4 Mon Sep 17 00:00:00 2001 From: riknel Date: Mon, 19 Dec 2016 18:00:29 +0300 Subject: [PATCH 04/10] Checkstyle fixes. --- .../kirilenko/task4/CalculatorController.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java index c4b1cd3b4..f1444d674 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -18,18 +18,18 @@ public class CalculatorController { @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.GET) - public @ResponseBody String getVariable(@PathVariable String variableName) { + public String getVariable(@PathVariable String variableName) { String result = calculator.getVariableExpression(variableName); return result; } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.GET) - public @ResponseBody String getFunction(@PathVariable String functionName) { + public String getFunction(@PathVariable String functionName) { Pair, String> info = calculator.getFunctionInfo(functionName); String result = info.getValue() + "&"; for (int i = 0; i < info.getKey().size(); i++) { result += info.getKey().get(i); - if (i != info.getKey().size()-1) { + if (i != info.getKey().size() - 1) { result += ","; } } @@ -38,7 +38,7 @@ public class CalculatorController { @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.PUT, consumes = "text/plain", produces = "text/plain") - public @ResponseBody void putVariable(@PathVariable String variableName, + public void putVariable(@PathVariable String variableName, @RequestBody String expr) throws ParsingException { calculator.setVariableExpression(variableName, expr); } @@ -49,25 +49,25 @@ public void deleteVariable(@PathVariable String variableName) { } @RequestMapping(path = "/variable", method = RequestMethod.GET) - public @ResponseBody ArrayList getVariables() { + public ArrayList getVariables() { return calculator.getAllVariables(); } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.PUT) - public @ResponseBody void putFunction(@PathVariable String functionName, + public void putFunction(@PathVariable String functionName, @RequestParam(value = "args") ArrayList args, @RequestBody String functionBody) throws ParsingException { calculator.setFunction(functionName, new ArrayList<>(args), functionBody); } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.DELETE) - public @ResponseBody Boolean deleteFunction(@PathVariable String functionName) { + public Boolean deleteFunction(@PathVariable String functionName) { return calculator.deleteFunction(functionName); } @RequestMapping(path = "/function", method = RequestMethod.GET) - public @ResponseBody ArrayList getFunctionsNames() { + public ArrayList getFunctionsNames() { return calculator.getAllFunctions(); } @@ -77,7 +77,7 @@ public String echo() { } @RequestMapping(path = "/eval", method = RequestMethod.POST, consumes = "text/plain", produces = "text/plain") - public @ResponseBody String eval(@RequestBody String expression) throws ParsingException { + public String eval(@RequestBody String expression) throws ParsingException { double result = calculator.evaluateExpression(expression); return Double.toString(result) + "\n"; } From 6059517d68d76cca04ed2eca5d5e4aea5aed16d6 Mon Sep 17 00:00:00 2001 From: riknel Date: Mon, 19 Dec 2016 18:03:46 +0300 Subject: [PATCH 05/10] Checkstyle fixes. --- .../g597/kirilenko/task4/MySpringApplication.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java index dac952ec6..fd763216e 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java @@ -11,7 +11,13 @@ import ru.mipt.java2016.homework.g597.kirilenko.task1.MyCalculator; -//curl http://localhost:9001/eval -X POST -H "Content-Type: text/plain" -H "Authorization: Basic $(echo -n "username:password" | base64)" --data-raw "44*3+2" +/** + * curl http://localhost:9001/eval \ + * -X POST \ + * -H "Content-Type: text/plain" \ + * -H "Authorization: Basic $(echo -n "username:password" | base64)" \ + * --data-raw "44*3+2" + */ @EnableAutoConfiguration @Configuration From 08af9dfb56494f32b33fb4d700c9e1deeb0a77bc Mon Sep 17 00:00:00 2001 From: riknel Date: Wed, 21 Dec 2016 04:00:38 +0300 Subject: [PATCH 06/10] First restructure. --- .../g597/kirilenko/task1/MyCalculator.java | 309 +--------- .../g597/kirilenko/task4/BillingDao.java | 27 +- .../g597/kirilenko/task4/BillingUser.java | 1 - .../kirilenko/task4/CalculatorController.java | 48 +- .../g597/kirilenko/task4/MyCalculator.java | 544 ++++++++++++++++++ 5 files changed, 602 insertions(+), 327 deletions(-) create mode 100644 homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java index f1477dd7f..191853d20 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task1/MyCalculator.java @@ -1,319 +1,15 @@ package ru.mipt.java2016.homework.g597.kirilenko.task1; - - -import javafx.util.Pair; import ru.mipt.java2016.homework.base.task1.Calculator; import ru.mipt.java2016.homework.base.task1.ParsingException; -import java.util.*; - -import static java.lang.Math.*; +import java.util.Stack; public class MyCalculator implements Calculator { private Stack numbers; private Stack operations; - private final Map variablesExpressions = new HashMap(); - private final Map, String>> functions = new HashMap(); - - private double calculateStandardExpression(String functionName, ArrayList arguments) - throws ParsingException { - if (functionName.equals("sin")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return sin(arguments.get(0)); - } - if (functionName.equals("cos")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return cos(arguments.get(0)); - } - if (functionName.equals("tg")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return tan(arguments.get(0)); - } - if (functionName.equals("sqrt")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return sqrt(arguments.get(0)); - } - if (functionName.equals("abs")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return abs(arguments.get(0)); - } - if (functionName.equals("max")) { - if (arguments.size() != 2) { - throw new ParsingException("Incorrect expression"); - } - return max(arguments.get(0), arguments.get(1)); - } - if (functionName.equals("min")) { - if (arguments.size() != 2) { - throw new ParsingException("Incorrect expression"); - } - return min(arguments.get(0), arguments.get(1)); - } - if (functionName.equals("pow")) { - if (arguments.size() != 2) { - throw new ParsingException("Incorrect expression"); - } - return pow(arguments.get(0), arguments.get(1)); - } - if (functionName.equals("log")) { - if (arguments.size() != 2) { - throw new ParsingException("Incorrect expression"); - } - return log(arguments.get(0)) / log(arguments.get(1)); - } - if (functionName.equals("log2")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return log(arguments.get(0)) / log(2); - } - if (functionName.equals("rnd")) { - if (arguments.size() != 0) { - throw new ParsingException("Incorrect expression"); - } - return random(); - } - if (functionName.equals("sign")) { - if (arguments.size() != 1) { - throw new ParsingException("Incorrect expression"); - } - return signum(arguments.get(0)); - } - throw new ParsingException("Not standard expression."); - } - - private boolean isStandardFunction(String functionName) { - return functionName.equals("sin") || - functionName.equals("cos") || - functionName.equals("tg") || - functionName.equals("sqrt") || - functionName.equals("pow") || - functionName.equals("abs") || - functionName.equals("sign") || - functionName.equals("log") || - functionName.equals("log2") || - functionName.equals("rnd") || - functionName.equals("max") || - functionName.equals("min"); - - } - - public String getVariableExpression(String variable) { - if (!variablesExpressions.keySet().contains(variable)) { - return null; - } - return variablesExpressions.get(variable); - } - - public void setVariableExpression(String variable, String expression) { - variablesExpressions.put(variable, expression); - } - - public void deleteVariable(String variable) { - variablesExpressions.remove(variable); - } - - public ArrayList getAllVariables() { - return new ArrayList<>(variablesExpressions.keySet()); - } - - public Pair, String> getFunctionInfo(String functionName) { - return functions.get(functionName); - } - - public boolean setFunction(String functionName, ArrayList arguments, String expression) { - if (isStandardFunction(functionName)) { - return false; - } - functions.put(functionName, new Pair<>(arguments, expression)); - return true; - } - - public boolean deleteFunction(String functionName) { - if (isStandardFunction(functionName)) { - return false; - } - functions.remove(functionName); - return true; - } - - public ArrayList getAllFunctions() { - return new ArrayList<>(functions.keySet()); - } - - private boolean isDigit(char c) { - return (c >= '0' && c <= '9'); - } - - private boolean isLatinSymbol(char c) { - return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); - } - - private boolean isUnderscore(char c) { - return c == '_'; - } - - private boolean isOpeningBracket(char c) { - return c == '('; - } - - - private Pair getValueLexem(String expression, Integer startIndex) { - Integer firstIndex = startIndex; - while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && - !isLatinSymbol(expression.charAt(firstIndex))) { - firstIndex += 1; - } - if (firstIndex >= expression.length()) { - return null; - } - Integer secondIndex = firstIndex; - while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || - isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { - secondIndex += 1; - } - if (secondIndex == expression.length() || expression.charAt(secondIndex) != '(') { - return new Pair<>(firstIndex, secondIndex); - } else { - return getValueLexem(expression, secondIndex + 1); - } - } - - private Pair>, ArrayList> getFunctionLexem(String expression) { - Integer firstIndex = 0; - while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && - !isLatinSymbol(expression.charAt(firstIndex))) { - firstIndex += 1; - } - if (firstIndex >= expression.length()) { - return null; - } - Integer secondIndex = firstIndex; - while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || - isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { - secondIndex += 1; - } - String name = expression.substring(firstIndex, secondIndex); - Pair, Integer> arg = getArguments(expression, secondIndex); - ArrayList arguments = arg.getKey(); - Integer lastIndex = arg.getValue(); - Pair indices = new Pair<>(firstIndex, lastIndex); - return new Pair<>(new Pair<>(name, indices), arguments); - } - - private Pair, Integer> getArguments(String expression, Integer startIndex) { - ArrayList arguments = new ArrayList<>(); - Integer lastIndex = 0; - Integer balance = 1; - Integer currentIndex = startIndex + 1; - String currentArgument = ""; - while (balance != 0) { //выражение уже проверено на корректность -> exception не выбрасываем - if (expression.charAt(currentIndex) == '(') { - balance += 1; - currentArgument += expression.charAt(currentIndex); - currentIndex++; - } else if (expression.charAt(currentIndex) == ')') { - balance -= 1; - currentArgument += expression.charAt(currentIndex); - currentIndex++; - } else if (balance == 1 && expression.charAt(currentIndex) == ',') { - arguments.add(currentArgument); - currentArgument = ""; - currentIndex++; - } else { - currentArgument += expression.charAt(currentIndex); - currentIndex++; - } - } - arguments.add(currentArgument.substring(0, currentArgument.length() - 1)); - return new Pair<>(arguments, currentIndex); - } - - private Pair findArgument(String expression, String argument) { - int lastIndex = expression.indexOf(argument, 0); - if (lastIndex == -1) { - return null; - } - return new Pair<>(lastIndex, lastIndex + argument.length()); - } - - private Double evaluateFunction(String expression, ArrayList argumentsList, - ArrayList arguments) throws ParsingException { - for (int i = 0; i < argumentsList.size(); i++) { - String argument = argumentsList.get(i); - Pair argCoord = findArgument(expression, argument); - while (argCoord != null) { - expression = expression.substring(0, argCoord.getKey()) + arguments.get(i).toString() + - expression.substring(argCoord.getValue(), expression.length()); - argCoord = findArgument(expression, argument); - } - } - try { - return evaluateExpression(expression); - } catch (ParsingException e) { - throw e; - } - } - - - - public double evaluateExpression(String expression) throws ParsingException { - expression = deleteSpaces(expression); - - - try { - Pair valueLexem = getValueLexem(expression, 0); - while (valueLexem != null) { - Integer start = valueLexem.getKey(); - Integer end = valueLexem.getValue(); - String valueName = expression.substring(start, end); - String valExpr = getVariableExpression(valueName); - Double result = evaluateExpression(valExpr); - expression = expression.substring(0, start) + result.toString() + - expression.substring(end, expression.length()); - valueLexem = getValueLexem(expression, 0); - } - Pair>, ArrayList> functionLexem = - getFunctionLexem(expression); - while (functionLexem != null) { - String functionName = functionLexem.getKey().getKey(); - Integer start = functionLexem.getKey().getValue().getKey(); - Integer end = functionLexem.getKey().getValue().getValue(); - ArrayList arguments = functionLexem.getValue(); - ArrayList calculatedArguments = new ArrayList<>(); - for (int i = 0; i < arguments.size(); i++) { - calculatedArguments.add(evaluateExpression(arguments.get(i))); - } - Double result = Double.NaN; - if (isStandardFunction(functionName)) { - result = calculateStandardExpression(functionName, calculatedArguments); - } else { - Pair, String> func = getFunctionInfo(functionName); - result = evaluateFunction(func.getValue(), func.getKey(), calculatedArguments); - } - expression = expression.substring(0, start) + result.toString() + - expression.substring(end, expression.length()); - functionLexem = getFunctionLexem(expression); - } - return calculate(expression); - } catch (ParsingException p) { - throw p; - } - } - @Override public double calculate(String expression) throws ParsingException { numbers = new Stack<>(); @@ -325,6 +21,7 @@ public double calculate(String expression) throws ParsingException { if (!checkForConsequentNumbers(expression)) { throw new ParsingException("Incorrect expression"); } + expression = deleteSpaces(expression); if (!checkIncorrectExpression(expression)) { throw new ParsingException("Incorrect expression"); } @@ -524,4 +221,4 @@ private boolean checkIncorrectExpression(String expres) { return true; } -} +} \ No newline at end of file diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java index 73c37b5a3..9ec434685 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java @@ -1,5 +1,6 @@ package ru.mipt.java2016.homework.g597.kirilenko.task4; +import javafx.util.Pair; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; @@ -12,6 +13,8 @@ import javax.sql.DataSource; import java.sql.ResultSet; import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Map; @Repository public class BillingDao { @@ -22,6 +25,19 @@ public class BillingDao { private JdbcTemplate jdbcTemplate; + // Будет синглтоном + public static final BillingDao INSTANCE = new BillingDao(); + + private BillingDao() {} + public static BillingDao getInstance() { + return INSTANCE; + } + + public Pair, Map, String>>> loadData(String username) { + return null; + // Здесь надо написать возврат + } + @PostConstruct public void postConstruct() { jdbcTemplate = new JdbcTemplate(dataSource, false); @@ -33,7 +49,16 @@ public void initSchema() { jdbcTemplate.execute("CREATE SCHEMA IF NOT EXISTS billing"); jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.users " + "(username VARCHAR PRIMARY KEY, password VARCHAR, enabled BOOLEAN)"); - jdbcTemplate.update("INSERT INTO billing.users VALUES ('username', 'password', TRUE)"); + jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.variables " + + "(username VARCHAR, name VARCHAR, value DOUBLE)"); + jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.functions " + + "(username VARCHAR, name VARCHAR, arguments VARCHAR, expression VARCHAR)"); + try { + loadUser("username"); + } catch (EmptyResultDataAccessException e) { + jdbcTemplate.update("INSERT INTO billing.users VALUES (?, ?, ?)", + new Object[]{"username", "password", true}); + } } diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java index 786f3e767..1308c8bc5 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingUser.java @@ -56,7 +56,6 @@ public boolean equals(Object o) { return false; } return password.equals(that.password); - } @Override diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java index f1444d674..0d9f188ed 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -4,9 +4,10 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.core.Authentication; import org.springframework.web.bind.annotation.*; import ru.mipt.java2016.homework.base.task1.ParsingException; -import ru.mipt.java2016.homework.g597.kirilenko.task1.MyCalculator; +import ru.mipt.java2016.homework.g597.kirilenko.task4.MyCalculator; import java.util.ArrayList; @@ -18,14 +19,16 @@ public class CalculatorController { @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.GET) - public String getVariable(@PathVariable String variableName) { - String result = calculator.getVariableExpression(variableName); + public String getVariable(Authentication auth, @PathVariable String variableName) { + String name = auth.getName(); + String result = calculator.getVariableExpression(name, variableName); return result; } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.GET) - public String getFunction(@PathVariable String functionName) { - Pair, String> info = calculator.getFunctionInfo(functionName); + public String getFunction(Authentication auth, @PathVariable String functionName) { + String name = auth.getName(); + Pair, String> info = calculator.getFunctionInfo(name, functionName); String result = info.getValue() + "&"; for (int i = 0; i < info.getKey().size(); i++) { result += info.getKey().get(i); @@ -38,37 +41,43 @@ public String getFunction(@PathVariable String functionName) { @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.PUT, consumes = "text/plain", produces = "text/plain") - public void putVariable(@PathVariable String variableName, + public void putVariable(Authentication auth, @PathVariable String variableName, @RequestBody String expr) throws ParsingException { - calculator.setVariableExpression(variableName, expr); + String name = auth.getName(); + calculator.setVariableExpression(name, variableName, expr); } @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.DELETE) - public void deleteVariable(@PathVariable String variableName) { - calculator.deleteVariable(variableName); + public void deleteVariable(Authentication auth, @PathVariable String variableName) { + String name = auth.getName(); + calculator.deleteVariable(name, variableName); } @RequestMapping(path = "/variable", method = RequestMethod.GET) - public ArrayList getVariables() { - return calculator.getAllVariables(); + public ArrayList getVariables(Authentication auth) { + String name = auth.getName(); + return calculator.getAllVariables(name); } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.PUT) - public void putFunction(@PathVariable String functionName, + public void putFunction(Authentication auth, @PathVariable String functionName, @RequestParam(value = "args") ArrayList args, @RequestBody String functionBody) throws ParsingException { - calculator.setFunction(functionName, new ArrayList<>(args), functionBody); + String name = auth.getName(); + calculator.setFunction(name, functionName, new ArrayList<>(args), functionBody); } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.DELETE) - public Boolean deleteFunction(@PathVariable String functionName) { - return calculator.deleteFunction(functionName); + public Boolean deleteFunction(Authentication auth, @PathVariable String functionName) { + String name = auth.getName(); + return calculator.deleteFunction(name, functionName); } @RequestMapping(path = "/function", method = RequestMethod.GET) - public ArrayList getFunctionsNames() { - return calculator.getAllFunctions(); + public ArrayList getFunctionsNames(Authentication auth) { + String name = auth.getName(); + return calculator.getAllFunctions(name); } @RequestMapping(path = "/ping", method = RequestMethod.GET, produces = "text/plain") @@ -77,8 +86,9 @@ public String echo() { } @RequestMapping(path = "/eval", method = RequestMethod.POST, consumes = "text/plain", produces = "text/plain") - public String eval(@RequestBody String expression) throws ParsingException { - double result = calculator.evaluateExpression(expression); + public String eval(Authentication auth, @RequestBody String expression) throws ParsingException { + String name = auth.getName(); + double result = calculator.evaluateExpression(name, expression); return Double.toString(result) + "\n"; } } diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java new file mode 100644 index 000000000..1a9409bdb --- /dev/null +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java @@ -0,0 +1,544 @@ +package ru.mipt.java2016.homework.g597.kirilenko.task4; + + +import javafx.util.Pair; +import ru.mipt.java2016.homework.base.task1.Calculator; +import ru.mipt.java2016.homework.base.task1.ParsingException; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Stack; + +import static java.lang.Math.*; + + +public class MyCalculator implements Calculator { + private Stack numbers; + private Stack operations; + + private Map variablesExpressions = new HashMap(); + private Map, String>> functions = new HashMap(); + + private void loadDataFromDao(String username) { + Pair, Map, String>>> res = BillingDao.getInstance().loadData(username); + variablesExpressions = res.getKey(); + functions = res.getValue(); + } + + private double calculateStandardExpression(String functionName, ArrayList arguments) + throws ParsingException { + if (functionName.equals("sin")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return sin(arguments.get(0)); + } + if (functionName.equals("cos")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return cos(arguments.get(0)); + } + if (functionName.equals("tg")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return tan(arguments.get(0)); + } + if (functionName.equals("sqrt")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return sqrt(arguments.get(0)); + } + if (functionName.equals("abs")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return abs(arguments.get(0)); + } + if (functionName.equals("max")) { + if (arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return max(arguments.get(0), arguments.get(1)); + } + if (functionName.equals("min")) { + if (arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return min(arguments.get(0), arguments.get(1)); + } + if (functionName.equals("pow")) { + if (arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return pow(arguments.get(0), arguments.get(1)); + } + if (functionName.equals("log")) { + if (arguments.size() != 2) { + throw new ParsingException("Incorrect expression"); + } + return log(arguments.get(0)) / log(arguments.get(1)); + } + if (functionName.equals("log2")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return log(arguments.get(0)) / log(2); + } + if (functionName.equals("rnd")) { + if (arguments.size() != 0) { + throw new ParsingException("Incorrect expression"); + } + return random(); + } + if (functionName.equals("sign")) { + if (arguments.size() != 1) { + throw new ParsingException("Incorrect expression"); + } + return signum(arguments.get(0)); + } + throw new ParsingException("Not standard expression."); + } + + private boolean isStandardFunction(String functionName) { + return functionName.equals("sin") || + functionName.equals("cos") || + functionName.equals("tg") || + functionName.equals("sqrt") || + functionName.equals("pow") || + functionName.equals("abs") || + functionName.equals("sign") || + functionName.equals("log") || + functionName.equals("log2") || + functionName.equals("rnd") || + functionName.equals("max") || + functionName.equals("min"); + + } + + public String getVariableExpression(String username, String variable) { + loadDataFromDao(String username) + if (!variablesExpressions.keySet().contains(variable)) { + return null; + } + return variablesExpressions.get(variable); + } + + public void setVariableExpression(String username, String variable, String expression) { + loadDataFromDao(String username) + variablesExpressions.put(variable, expression); + } + + public void deleteVariable(String username, String variable) { + loadDataFromDao(String username) + variablesExpressions.remove(variable); + } + + public ArrayList getAllVariables(String username) { + loadDataFromDao(String username) + return new ArrayList<>(variablesExpressions.keySet()); + } + + public Pair, String> getFunctionInfo(String username, String functionName) { + loadDataFromDao(String username) + return functions.get(functionName); + } + + public boolean setFunction(String username, String functionName, ArrayList arguments, String expression) { + loadDataFromDao(String username) + if (isStandardFunction(functionName)) { + return false; + } + functions.put(functionName, new Pair<>(arguments, expression)); + return true; + } + + public boolean deleteFunction(String username, String functionName) { + loadDataFromDao(String username) + if (isStandardFunction(functionName)) { + return false; + } + functions.remove(functionName); + return true; + } + + public ArrayList getAllFunctions(String username) { + loadDataFromDao(String username) + return new ArrayList<>(functions.keySet()); + } + + private boolean isDigit(char c) { + return (c >= '0' && c <= '9'); + } + + private boolean isLatinSymbol(char c) { + return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); + } + + private boolean isUnderscore(char c) { + return c == '_'; + } + + private boolean isOpeningBracket(char c) { + return c == '('; + } + + + private Pair getValueLexem(String expression, Integer startIndex) { + Integer firstIndex = startIndex; + while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && + !isLatinSymbol(expression.charAt(firstIndex))) { + firstIndex += 1; + } + if (firstIndex >= expression.length()) { + return null; + } + Integer secondIndex = firstIndex; + while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || + isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { + secondIndex += 1; + } + if (secondIndex == expression.length() || expression.charAt(secondIndex) != '(') { + return new Pair<>(firstIndex, secondIndex); + } else { + return getValueLexem(expression, secondIndex + 1); + } + } + + private Pair>, ArrayList> getFunctionLexem(String expression) { + Integer firstIndex = 0; + while (firstIndex < expression.length() && !isUnderscore(expression.charAt(firstIndex)) && + !isLatinSymbol(expression.charAt(firstIndex))) { + firstIndex += 1; + } + if (firstIndex >= expression.length()) { + return null; + } + Integer secondIndex = firstIndex; + while (secondIndex < expression.length() && (isUnderscore(expression.charAt(secondIndex)) || + isLatinSymbol(expression.charAt(secondIndex)) || isDigit(expression.charAt(secondIndex)))) { + secondIndex += 1; + } + String name = expression.substring(firstIndex, secondIndex); + Pair, Integer> arg = getArguments(expression, secondIndex); + ArrayList arguments = arg.getKey(); + Integer lastIndex = arg.getValue(); + Pair indices = new Pair<>(firstIndex, lastIndex); + return new Pair<>(new Pair<>(name, indices), arguments); + } + + private Pair, Integer> getArguments(String expression, Integer startIndex) { + ArrayList arguments = new ArrayList<>(); + Integer lastIndex = 0; + Integer balance = 1; + Integer currentIndex = startIndex + 1; + String currentArgument = ""; + while (balance != 0) { //выражение уже проверено на корректность -> exception не выбрасываем + if (expression.charAt(currentIndex) == '(') { + balance += 1; + currentArgument += expression.charAt(currentIndex); + currentIndex++; + } else if (expression.charAt(currentIndex) == ')') { + balance -= 1; + currentArgument += expression.charAt(currentIndex); + currentIndex++; + } else if (balance == 1 && expression.charAt(currentIndex) == ',') { + arguments.add(currentArgument); + currentArgument = ""; + currentIndex++; + } else { + currentArgument += expression.charAt(currentIndex); + currentIndex++; + } + } + arguments.add(currentArgument.substring(0, currentArgument.length() - 1)); + return new Pair<>(arguments, currentIndex); + } + + private Pair findArgument(String expression, String argument) { + int lastIndex = expression.indexOf(argument, 0); + if (lastIndex == -1) { + return null; + } + return new Pair<>(lastIndex, lastIndex + argument.length()); + } + + private Double evaluateFunction(String expression, ArrayList argumentsList, + ArrayList arguments) throws ParsingException { + for (int i = 0; i < argumentsList.size(); i++) { + String argument = argumentsList.get(i); + Pair argCoord = findArgument(expression, argument); + while (argCoord != null) { + expression = expression.substring(0, argCoord.getKey()) + arguments.get(i).toString() + + expression.substring(argCoord.getValue(), expression.length()); + argCoord = findArgument(expression, argument); + } + } + try { + return evaluateExpression(expression); + } catch (ParsingException e) { + throw e; + } + } + + + + public double evaluateExpression(String username, String expression) throws ParsingException { + loadDataFromDao(String username) + expression = deleteSpaces(expression); + + + try { + Pair valueLexem = getValueLexem(expression, 0); + while (valueLexem != null) { + Integer start = valueLexem.getKey(); + Integer end = valueLexem.getValue(); + String valueName = expression.substring(start, end); + String valExpr = getVariableExpression(valueName); + Double result = evaluateExpression(valExpr); + expression = expression.substring(0, start) + result.toString() + + expression.substring(end, expression.length()); + valueLexem = getValueLexem(expression, 0); + } + Pair>, ArrayList> functionLexem = + getFunctionLexem(expression); + while (functionLexem != null) { + String functionName = functionLexem.getKey().getKey(); + Integer start = functionLexem.getKey().getValue().getKey(); + Integer end = functionLexem.getKey().getValue().getValue(); + ArrayList arguments = functionLexem.getValue(); + ArrayList calculatedArguments = new ArrayList<>(); + for (int i = 0; i < arguments.size(); i++) { + calculatedArguments.add(evaluateExpression(arguments.get(i))); + } + Double result = Double.NaN; + if (isStandardFunction(functionName)) { + result = calculateStandardExpression(functionName, calculatedArguments); + } else { + Pair, String> func = getFunctionInfo(functionName); + result = evaluateFunction(func.getValue(), func.getKey(), calculatedArguments); + } + expression = expression.substring(0, start) + result.toString() + + expression.substring(end, expression.length()); + functionLexem = getFunctionLexem(expression); + } + return calculate(expression); + } catch (ParsingException p) { + throw p; + } + } + + @Override + public double calculate(String expression) throws ParsingException { + numbers = new Stack<>(); + operations = new Stack<>(); + try { + if (expression == null) { + throw new ParsingException("Incorrect expression"); + } + if (!checkForConsequentNumbers(expression)) { + throw new ParsingException("Incorrect expression"); + } + if (!checkIncorrectExpression(expression)) { + throw new ParsingException("Incorrect expression"); + } + return toRPH(expression); + } finally { + numbers = null; + operations = null; + } + + } + + private boolean checkForConsequentNumbers(String expres) { + //между любыми двумя числами должен стоять оператор (тесты вида 1 2, 1(2) + boolean opBetween = true; + boolean notString = true; + for (int i = 0; i < expres.length(); i++) { + char c = expres.charAt(i); + if (c == '*' || c == '/' || c == '+' || c == '-') { + opBetween = true; + notString = true; + } else if (Character.isDigit(c) || c == '.') { + if (notString && !opBetween) { + return false; + } + notString = false; + opBetween = false; + } else { + notString = true; + } + } + return true; + } + + private int priority(char c) { + if (c == '+' || c == '-') { + return 1; + } else if (c == '*' || c == '/') { + return 2; + } else if (c == 'M') { + return 3; + } else { + return -1; + } + } + + private void calculationOperator(char c) { + if (c == 'M') { + double a = numbers.pop(); + numbers.push(-a); + return; + } + double a = numbers.pop(); + double b = numbers.pop(); + if (c == '+') { + numbers.push(a + b); + } else if (c == '-') { + numbers.push(b - a); + } else if (c == '*') { + numbers.push(b * a); + } else if (c == '/') { + numbers.push(b / a); + } + } + + private double toRPH(String expression) throws ParsingException { + boolean isUnary = true; //перед унарным минусом стоит либо операция, либо ( + for (int i = 0; i < expression.length(); ++i) { + char c = expression.charAt(i); + if (c == '(') { + isUnary = true; + operations.push(c); + } else if (c == ')') { + //вычиляем значение в скобках + while (operations.peek() != '(') { + calculationOperator(operations.peek()); + operations.pop(); + } + isUnary = false; + //после ')' не может быть унарного минуса + operations.pop(); + + } else if (c == '+' || c == '-' || c == '*' || c == '/') { + if (isUnary && c == '-') { + c = 'M'; + } + //сначала выполняем операции с большим приоритетом + while (!operations.isEmpty() && ((c != 'M' && + priority(operations.peek()) >= priority(c)) || (c == 'M' + && priority(operations.peek()) > priority(c)))) { + calculationOperator(operations.peek()); + operations.pop(); + } + operations.push(c); + isUnary = true; + } else { + String operand = ""; + //находим десятичное число и добавляем его в вектор чисел + while (i < expression.length() && + (Character.isDigit(expression.charAt(i)) + || expression.charAt(i) == '.')) { + operand += expression.charAt(i); + i++; + } + i--; + numbers.push(Double.parseDouble(operand)); + isUnary = false; + //после числа не может стоять унарый минус + } + } + //выполняем оставшиеся операции над получившимися числами из numbers + while (!operations.isEmpty()) { + calculationOperator(operations.peek()); + operations.pop(); + } + if (numbers.size() != 1) { + throw new ParsingException("Invalid expression."); + } + return numbers.peek(); + } + + private String deleteSpaces(String expression) { + String expres = ""; + for (int i = 0; i < expression.length(); ++i) { + if (expression.charAt(i) != ' ' && expression.charAt(i) != '\t' && expression.charAt(i) != '\n') { + expres += Character.toString(expression.charAt(i)); + } + } + return expres; + } + + private boolean checkIncorrectExpression(String expres) { + int bracketResult = 0; + //выражение непусто + //на первом месте не стоят бинарные операции + //на последнем месте либо цифра, либо ')' + if (expres.length() == 0 || expres.charAt(0) == '*' + || expres.charAt(0) == '/' || expres.charAt(0) == '+' + || !(Character.isDigit(expres.charAt(expres.length() - 1)) + || expres.charAt(expres.length() - 1) == ')')) { + return false; + } + for (int i = 0; i < expres.length(); ++i) { + if (expres.charAt(i) == '(') { + bracketResult += 1; + } + if (expres.charAt(i) == ')') { + bracketResult -= 1; + } + //после оператора не стоит бинарный оператор(то есть не *, /, +) + if (expres.charAt(i) == '-' || expres.charAt(i) == '+' + || expres.charAt(i) == '/' || expres.charAt(i) == '*') { + if (i + 1 >= expres.length() || expres.charAt(i + 1) == '+' + || expres.charAt(i + 1) == '/' || expres.charAt(i + 1) == '*') { + return false; + } + } + //проверка на некорректные символы + if (!(Character.isDigit(expres.charAt(i)) || expres.charAt(i) == '.' + || expres.charAt(i) == '(' || expres.charAt(i) == ')' + || expres.charAt(i) == '+' || expres.charAt(i) == '-' || + expres.charAt(i) == '*' || expres.charAt(i) == '/')) { + return false; + } + //проверка на неотрицательный скобочный итог + if (bracketResult < 0) { + return false; + } + //*, /, + не являются бинарными операторами, то есть они не могут стоять после '(' + //также пустые скобки считаются некорретным выражением + if (expres.charAt(i) == '(') { + if (i + 1 >= expres.length() || (expres.charAt(i + 1) == '+' + || expres.charAt(i + 1) == '*' || + expres.charAt(i + 1) == '/' || expres.charAt(i + 1) == ')')) { + return false; + } + } + } + if (bracketResult != 0) { + return false; + } + //проверка на корректность десятичного выражения(в каждом числе не больше одной '.') + int dot = 0; + int i = 0; + while (i < expres.length() && dot < 2) { + if (expres.charAt(i) == '+' || expres.charAt(i) == '-' + || expres.charAt(i) == '/' || expres.charAt(i) == '*') { + dot = 0; + } + if (expres.charAt(i) == '.') { + dot += 1; + } + i++; + } + if (dot >= 2) { + return false; + } + return true; + + } +} From 054a1e73442aa22865c20c0d053fdbbde9715e81 Mon Sep 17 00:00:00 2001 From: riknel Date: Wed, 21 Dec 2016 09:43:28 +0300 Subject: [PATCH 07/10] Fixes. --- homework-g597-kirilenko/pom.xml | 5 -- .../g597/kirilenko/task4/BillingDao.java | 29 +--------- .../task4/BillingDatabaseConfiguration.java | 2 +- .../kirilenko/task4/CalculatorController.java | 54 ++++++++----------- .../g597/kirilenko/task4/MyCalculator.java | 37 ++++--------- .../kirilenko/task4/MySpringApplication.java | 2 +- .../task4/SecurityServiceConfiguration.java | 2 +- 7 files changed, 38 insertions(+), 93 deletions(-) diff --git a/homework-g597-kirilenko/pom.xml b/homework-g597-kirilenko/pom.xml index f091bb3a0..0b4dcc2f0 100644 --- a/homework-g597-kirilenko/pom.xml +++ b/homework-g597-kirilenko/pom.xml @@ -28,11 +28,6 @@ 1.0.0 test - - net.sourceforge.jeval - jeval - 0.9.4 - org.springframework.boot diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java index 9ec434685..b4a799a65 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDao.java @@ -1,6 +1,5 @@ package ru.mipt.java2016.homework.g597.kirilenko.task4; -import javafx.util.Pair; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; @@ -13,8 +12,6 @@ import javax.sql.DataSource; import java.sql.ResultSet; import java.sql.SQLException; -import java.util.ArrayList; -import java.util.Map; @Repository public class BillingDao { @@ -25,19 +22,6 @@ public class BillingDao { private JdbcTemplate jdbcTemplate; - // Будет синглтоном - public static final BillingDao INSTANCE = new BillingDao(); - - private BillingDao() {} - public static BillingDao getInstance() { - return INSTANCE; - } - - public Pair, Map, String>>> loadData(String username) { - return null; - // Здесь надо написать возврат - } - @PostConstruct public void postConstruct() { jdbcTemplate = new JdbcTemplate(dataSource, false); @@ -49,16 +33,7 @@ public void initSchema() { jdbcTemplate.execute("CREATE SCHEMA IF NOT EXISTS billing"); jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.users " + "(username VARCHAR PRIMARY KEY, password VARCHAR, enabled BOOLEAN)"); - jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.variables " + - "(username VARCHAR, name VARCHAR, value DOUBLE)"); - jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS billing.functions " + - "(username VARCHAR, name VARCHAR, arguments VARCHAR, expression VARCHAR)"); - try { - loadUser("username"); - } catch (EmptyResultDataAccessException e) { - jdbcTemplate.update("INSERT INTO billing.users VALUES (?, ?, ?)", - new Object[]{"username", "password", true}); - } + jdbcTemplate.update("INSERT INTO billing.users VALUES ('username', 'password', TRUE)"); } @@ -79,4 +54,4 @@ public BillingUser mapRow(ResultSet rs, int rowNum) throws SQLException { } ); } -} +} \ No newline at end of file diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java index a85926517..dda68971e 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/BillingDatabaseConfiguration.java @@ -12,12 +12,12 @@ public class BillingDatabaseConfiguration { @Bean public DataSource billingDataSource( - @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.jdbcUrl}") String jdbcUrl, @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.username:}") String username, @Value("${ru.mipt.java2016.homework.g597.kirilenko.task4.password:}") String password ) { HikariConfig config = new HikariConfig(); config.setDriverClassName(org.h2.Driver.class.getName()); + String jdbcUrl = "jdbc:h2:~/task4.db"; config.setJdbcUrl(jdbcUrl); config.setUsername(username); config.setPassword(password); diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java index 0d9f188ed..608b239a6 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -4,7 +4,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.security.core.Authentication; import org.springframework.web.bind.annotation.*; import ru.mipt.java2016.homework.base.task1.ParsingException; import ru.mipt.java2016.homework.g597.kirilenko.task4.MyCalculator; @@ -19,16 +18,14 @@ public class CalculatorController { @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.GET) - public String getVariable(Authentication auth, @PathVariable String variableName) { - String name = auth.getName(); - String result = calculator.getVariableExpression(name, variableName); + public String getVariable(@PathVariable String variableName) { + String result = calculator.getVariableExpression(variableName); return result; } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.GET) - public String getFunction(Authentication auth, @PathVariable String functionName) { - String name = auth.getName(); - Pair, String> info = calculator.getFunctionInfo(name, functionName); + public String getFunction(@PathVariable String functionName) { + Pair, String> info = calculator.getFunctionInfo(functionName); String result = info.getValue() + "&"; for (int i = 0; i < info.getKey().size(); i++) { result += info.getKey().get(i); @@ -41,43 +38,37 @@ public String getFunction(Authentication auth, @PathVariable String functionName @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.PUT, consumes = "text/plain", produces = "text/plain") - public void putVariable(Authentication auth, @PathVariable String variableName, - @RequestBody String expr) throws ParsingException { - String name = auth.getName(); - calculator.setVariableExpression(name, variableName, expr); + public void putVariable(@PathVariable String variableName, + @RequestBody String expr) throws ParsingException { + calculator.setVariableExpression(variableName, expr); } @RequestMapping(path = "/variable/{variableName}", method = RequestMethod.DELETE) - public void deleteVariable(Authentication auth, @PathVariable String variableName) { - String name = auth.getName(); - calculator.deleteVariable(name, variableName); + public void deleteVariable(@PathVariable String variableName) { + calculator.deleteVariable(variableName); } @RequestMapping(path = "/variable", method = RequestMethod.GET) - public ArrayList getVariables(Authentication auth) { - String name = auth.getName(); - return calculator.getAllVariables(name); + public ArrayList getVariables() { + return calculator.getAllVariables(); } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.PUT) - public void putFunction(Authentication auth, @PathVariable String functionName, - @RequestParam(value = "args") ArrayList args, - @RequestBody String functionBody) throws ParsingException { - String name = auth.getName(); - calculator.setFunction(name, functionName, new ArrayList<>(args), functionBody); + public void putFunction(@PathVariable String functionName, + @RequestParam(value = "args") ArrayList args, + @RequestBody String functionBody) throws ParsingException { + calculator.setFunction(functionName, new ArrayList<>(args), functionBody); } @RequestMapping(path = "/function/{functionName}", method = RequestMethod.DELETE) - public Boolean deleteFunction(Authentication auth, @PathVariable String functionName) { - String name = auth.getName(); - return calculator.deleteFunction(name, functionName); + public Boolean deleteFunction(@PathVariable String functionName) { + return calculator.deleteFunction(functionName); } @RequestMapping(path = "/function", method = RequestMethod.GET) - public ArrayList getFunctionsNames(Authentication auth) { - String name = auth.getName(); - return calculator.getAllFunctions(name); + public ArrayList getFunctionsNames() { + return calculator.getAllFunctions(); } @RequestMapping(path = "/ping", method = RequestMethod.GET, produces = "text/plain") @@ -86,9 +77,8 @@ public String echo() { } @RequestMapping(path = "/eval", method = RequestMethod.POST, consumes = "text/plain", produces = "text/plain") - public String eval(Authentication auth, @RequestBody String expression) throws ParsingException { - String name = auth.getName(); - double result = calculator.evaluateExpression(name, expression); + public String eval(@RequestBody String expression) throws ParsingException { + double result = calculator.evaluateExpression(expression); return Double.toString(result) + "\n"; } -} +} \ No newline at end of file diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java index 1a9409bdb..1c25aa379 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MyCalculator.java @@ -17,14 +17,8 @@ public class MyCalculator implements Calculator { private Stack numbers; private Stack operations; - private Map variablesExpressions = new HashMap(); - private Map, String>> functions = new HashMap(); - - private void loadDataFromDao(String username) { - Pair, Map, String>>> res = BillingDao.getInstance().loadData(username); - variablesExpressions = res.getKey(); - functions = res.getValue(); - } + private final Map variablesExpressions = new HashMap(); + private final Map, String>> functions = new HashMap(); private double calculateStandardExpression(String functionName, ArrayList arguments) throws ParsingException { @@ -119,36 +113,30 @@ private boolean isStandardFunction(String functionName) { } - public String getVariableExpression(String username, String variable) { - loadDataFromDao(String username) + public String getVariableExpression(String variable) { if (!variablesExpressions.keySet().contains(variable)) { return null; } return variablesExpressions.get(variable); } - public void setVariableExpression(String username, String variable, String expression) { - loadDataFromDao(String username) + public void setVariableExpression(String variable, String expression) { variablesExpressions.put(variable, expression); } - public void deleteVariable(String username, String variable) { - loadDataFromDao(String username) + public void deleteVariable(String variable) { variablesExpressions.remove(variable); } - public ArrayList getAllVariables(String username) { - loadDataFromDao(String username) + public ArrayList getAllVariables() { return new ArrayList<>(variablesExpressions.keySet()); } - public Pair, String> getFunctionInfo(String username, String functionName) { - loadDataFromDao(String username) + public Pair, String> getFunctionInfo(String functionName) { return functions.get(functionName); } - public boolean setFunction(String username, String functionName, ArrayList arguments, String expression) { - loadDataFromDao(String username) + public boolean setFunction(String functionName, ArrayList arguments, String expression) { if (isStandardFunction(functionName)) { return false; } @@ -156,8 +144,7 @@ public boolean setFunction(String username, String functionName, ArrayList getAllFunctions(String username) { - loadDataFromDao(String username) + public ArrayList getAllFunctions() { return new ArrayList<>(functions.keySet()); } @@ -286,8 +272,7 @@ private Double evaluateFunction(String expression, ArrayList argumentsLi - public double evaluateExpression(String username, String expression) throws ParsingException { - loadDataFromDao(String username) + public double evaluateExpression(String expression) throws ParsingException { expression = deleteSpaces(expression); diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java index fd763216e..ffe45e149 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java @@ -9,7 +9,7 @@ import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; -import ru.mipt.java2016.homework.g597.kirilenko.task1.MyCalculator; +import ru.mipt.java2016.homework.g597.kirilenko.task4.MyCalculator; /** * curl http://localhost:9001/eval \ diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java index 5796f4586..6f7f1d196 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/SecurityServiceConfiguration.java @@ -31,7 +31,7 @@ protected void configure(HttpSecurity http) throws Exception { .logout().disable() .csrf().disable() .authorizeRequests() - .antMatchers("/eval/**").authenticated() + .antMatchers("/**").authenticated() .anyRequest().permitAll(); } From 746d352b9d8590f72c1acf95ef47bf3de4b2b65b Mon Sep 17 00:00:00 2001 From: riknel Date: Wed, 21 Dec 2016 09:45:32 +0300 Subject: [PATCH 08/10] Fixes. --- .../task4/CalculatorController.java | 2 +- homework-g594-glebov/pom.xml | 31 +++++++++++++++++++ .../kirilenko/task4/CalculatorController.java | 1 - .../kirilenko/task4/MySpringApplication.java | 2 -- 4 files changed, 32 insertions(+), 4 deletions(-) diff --git a/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java b/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java index 322960596..ea68546d7 100644 --- a/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java +++ b/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java @@ -11,7 +11,7 @@ public class CalculatorController { private static final Logger LOG = LoggerFactory.getLogger(CalculatorController.class); @Autowired - private Calculator calculator; + private calculator calculator; @RequestMapping(path = "/ping", method = RequestMethod.GET, produces = "text/plain") public String echo() { diff --git a/homework-g594-glebov/pom.xml b/homework-g594-glebov/pom.xml index 8dc443623..2bbbb6840 100644 --- a/homework-g594-glebov/pom.xml +++ b/homework-g594-glebov/pom.xml @@ -16,6 +16,37 @@ homework-base 1.0.0 + + net.sourceforge.jeval + jeval + 0.9.4 + + + + org.springframework.boot + spring-boot-starter-web + ${spring.boot.version} + + + org.springframework.boot + spring-boot-starter-jdbc + ${spring.boot.version} + + + org.springframework.boot + spring-boot-starter-security + ${spring.boot.version} + + + com.zaxxer + HikariCP + 2.5.1 + + + com.h2database + h2 + 1.4.193 + ru.mipt.java2016 homework-tests diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java index 608b239a6..97264b97d 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/CalculatorController.java @@ -6,7 +6,6 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import ru.mipt.java2016.homework.base.task1.ParsingException; -import ru.mipt.java2016.homework.g597.kirilenko.task4.MyCalculator; import java.util.ArrayList; diff --git a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java index ffe45e149..19eea25ee 100644 --- a/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java +++ b/homework-g597-kirilenko/src/main/java/ru/mipt/java2016/homework/g597/kirilenko/task4/MySpringApplication.java @@ -9,8 +9,6 @@ import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; -import ru.mipt.java2016.homework.g597.kirilenko.task4.MyCalculator; - /** * curl http://localhost:9001/eval \ * -X POST \ From c24d5559abe6c7d5e8cd138870a43d2b5cdd68b6 Mon Sep 17 00:00:00 2001 From: riknel Date: Wed, 21 Dec 2016 09:48:40 +0300 Subject: [PATCH 09/10] Fixes. --- homework-g594-glebov/pom.xml | 31 ------------------------------- 1 file changed, 31 deletions(-) diff --git a/homework-g594-glebov/pom.xml b/homework-g594-glebov/pom.xml index 2bbbb6840..8dc443623 100644 --- a/homework-g594-glebov/pom.xml +++ b/homework-g594-glebov/pom.xml @@ -16,37 +16,6 @@ homework-base 1.0.0 - - net.sourceforge.jeval - jeval - 0.9.4 - - - - org.springframework.boot - spring-boot-starter-web - ${spring.boot.version} - - - org.springframework.boot - spring-boot-starter-jdbc - ${spring.boot.version} - - - org.springframework.boot - spring-boot-starter-security - ${spring.boot.version} - - - com.zaxxer - HikariCP - 2.5.1 - - - com.h2database - h2 - 1.4.193 - ru.mipt.java2016 homework-tests From dfb6800229725eb2e60c1ce6f4f05e0e6412aaa0 Mon Sep 17 00:00:00 2001 From: riknel Date: Wed, 21 Dec 2016 09:51:02 +0300 Subject: [PATCH 10/10] Fixes. --- .../homework/g000/lavrentyev/task4/CalculatorController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java b/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java index ea68546d7..322960596 100644 --- a/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java +++ b/homework-g000-lavrentyev/src/main/java/ru/mipt/java2016/homework/g000/lavrentyev/task4/CalculatorController.java @@ -11,7 +11,7 @@ public class CalculatorController { private static final Logger LOG = LoggerFactory.getLogger(CalculatorController.class); @Autowired - private calculator calculator; + private Calculator calculator; @RequestMapping(path = "/ping", method = RequestMethod.GET, produces = "text/plain") public String echo() {