From 5512f5bfef6ff0bbd43263fb9777f3a588afe2ed Mon Sep 17 00:00:00 2001 From: Levi506 Date: Sat, 15 Oct 2022 22:24:49 -0500 Subject: [PATCH 1/3] Completed testing suite moving to extras Signed-off-by: Levi506 --- .../controller/SimpleDataToolController.java | 161 ++++++++++++++++-- 1 file changed, 144 insertions(+), 17 deletions(-) diff --git a/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java b/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java index fc50da3..4f0113f 100644 --- a/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java +++ b/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java @@ -1,18 +1,14 @@ package com.statefarm.codingcompetition.simpledatatool.controller; -import java.io.FileReader; -import java.io.Reader; -import java.util.ArrayList; +import java.io.File; +import java.io.IOException; import java.util.HashMap; +import java.util.LinkedList; import java.util.List; import java.util.Map; -import java.util.Optional; -import java.util.Map.Entry; -import java.util.stream.Collectors; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.MappingIterator; -import com.fasterxml.jackson.databind.ObjectReader; import com.fasterxml.jackson.dataformat.csv.CsvMapper; import com.fasterxml.jackson.dataformat.csv.CsvSchema; import com.statefarm.codingcompetition.simpledatatool.model.Agent; @@ -31,7 +27,23 @@ public class SimpleDataToolController { * @return List of entries from CSV file */ public List readCsvFile(String filePath, Class classType) { - return null; + try{ + + File file = new File(filePath); + CsvMapper mapper = new CsvMapper(); + mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); + CsvSchema Schema = CsvSchema.emptySchema().withHeader(); + + + MappingIterator it = mapper.readerFor(classType).with(Schema).readValues(file); + List ans = it.readAll(); + return ans; + + + } catch (IOException e) { + e.printStackTrace(); + } + return null; } /** @@ -41,7 +53,8 @@ public List readCsvFile(String filePath, Class classType) { * @return number of open claims */ public int getNumberOfOpenClaims(List claims) { - return 0; + claims.removeIf(c -> !c.getIsClaimOpen()); + return claims.size(); } /** @@ -52,7 +65,10 @@ public int getNumberOfOpenClaims(List claims) { * @return number of customer for agent */ public int getNumberOfCustomersForAgentId(String filePath, int agentId) { - return 0; + List cust = readCsvFile(filePath, Customer.class); + cust.removeIf(c -> c.getAgentId() != agentId); + + return cust.size(); } /** @@ -63,7 +79,10 @@ public int getNumberOfCustomersForAgentId(String filePath, int agentId) { * @return number of customer for agent */ public int getNumberOfAgentsForState(String filePath, String state) { - return 0; + List agents = readCsvFile(filePath, Agent.class); + agents.removeIf(a -> !a.getState().equals(state)); + + return agents.size(); } /** @@ -74,7 +93,14 @@ public int getNumberOfAgentsForState(String filePath, String state) { * @return float of monthly premium */ public double sumMonthlyPremiumForCustomerId(List policies, int customerId) { - return 0d; + //Copy the given List as all situations this method is used it needs to be untouched + List policiesCopy = new LinkedList<>(policies); + policiesCopy.removeIf(p -> p.getCustomerId() != customerId); + double policyTotal = 0d; + for(Policy custPolicy: policiesCopy){ + policyTotal += custPolicy.getPremiumPerMonth(); + } + return policyTotal; } /** @@ -90,7 +116,29 @@ public double sumMonthlyPremiumForCustomerId(List policies, int customer */ public Integer getNumberOfOpenClaimsForCustomerName(String filePathToCustomer, String filePathToPolicy, String filePathToClaims, String firstName, String lastName) { - return null; + + + List cust = readCsvFile(filePathToCustomer, Customer.class); + cust.removeIf(c-> !c.getFirstName().equals(firstName)); + cust.removeIf(c -> !c.getLastName().equals(lastName)); + if(cust.size() == 0){ + return null; + } + Customer customer = cust.get(0); + + List policies = readCsvFile(filePathToPolicy, Policy.class); + policies.removeIf(p -> p.getCustomerId() != customer.getId()); + List policyIds = new LinkedList<>(); + for(Policy p : policies){ + policyIds.add(p.getId()); + } + + List claims = readCsvFile(filePathToClaims, Claim.class); + claims.removeIf(claim -> !policyIds.contains(claim.getPolicyId())); + claims.removeIf(claim -> !claim.getIsClaimOpen()); + + return claims.size(); + } /** @@ -102,7 +150,42 @@ public Integer getNumberOfOpenClaimsForCustomerName(String filePathToCustomer, S * @return String of language */ public String getMostSpokenLanguageForState(String customersFilePath, String state) { - return null; + List cust = readCsvFile(customersFilePath, Customer.class); + Map languageSpeakers = new HashMap<>(); + cust.removeIf(c-> !c.getState().equals(state)); + + for(Customer customer: cust){ + if(!customer.getPrimaryLanguage().equals("English")){ + languageSpeakersHelper(languageSpeakers, customer.getPrimaryLanguage()); + } + + if(!customer.getSecondaryLanguage().isEmpty() && !customer.getSecondaryLanguage().equals("English")){ + languageSpeakersHelper(languageSpeakers, customer.getSecondaryLanguage()); + } + } + + List keys = new LinkedList<>(languageSpeakers.keySet()); + + keys.sort((k1,k2)-> languageSpeakers.get(k2) - languageSpeakers.get(k1)); + + + return keys.get(0); + } + + /** + * Helper method for getMostSpokenLanguageForState + * + * @param languageSpeakers State abbreviation String + * @param language + */ + private void languageSpeakersHelper(Map languageSpeakers,String language){ + if(languageSpeakers.containsKey(language)){ + int speakers = languageSpeakers.get(language); + speakers++; + languageSpeakers.put(language,speakers); + return; + } + languageSpeakers.put(language,1); } /** @@ -113,7 +196,15 @@ public String getMostSpokenLanguageForState(String customersFilePath, String sta * @return Customer that has the highest, total premium as Customer object */ public Customer getCustomerWithHighestTotalPremium(String customersFilePath, List policies) { - return null; + List cust = readCsvFile(customersFilePath, Customer.class); + Map premiumTotals = new HashMap<>(); + for(Customer customer : cust){ + premiumTotals.put(customer.getId() - 1, sumMonthlyPremiumForCustomerId(policies, customer.getId())); + } + List keys = new LinkedList(premiumTotals.keySet()); + keys.sort((k1,k2) -> (int)(Math.ceil(premiumTotals.get(k2)) - Math.ceil(premiumTotals.get(k1)))); + + return cust.get(keys.get(0)); } /** @@ -127,7 +218,24 @@ public Customer getCustomerWithHighestTotalPremium(String customersFilePath, Lis */ public int getOpenClaimsForState(String customersFilePath, String policiesFilePath, String claimsFilePath, String state) { - return 0; + List cust = readCsvFile(customersFilePath, Customer.class); + cust.removeIf(c-> c.getState().equals(state)); + + List policies = readCsvFile(policiesFilePath, Policy.class); + for(Customer customer:cust){ + policies.removeIf(p -> p.getCustomerId() == customer.getId()); + } + List PolicyIds = new LinkedList<>(); + for(Policy custPolicy : policies){ + PolicyIds.add(custPolicy.getId()); + } + + List claims = readCsvFile(claimsFilePath, Claim.class); + claims.removeIf(c -> !PolicyIds.contains(c.getPolicyId())); + claims.removeIf(c-> !c.getIsClaimOpen()); + + + return claims.size(); } /** @@ -140,6 +248,25 @@ public int getOpenClaimsForState(String customersFilePath, String policiesFilePa */ public Map buildMapOfAgentPremiums( String customersFilePath, String policiesFilePath) { - return null; + List cust = readCsvFile(customersFilePath, Customer.class); + Map customerAgent = new HashMap<>(); + for(Customer customer:cust){ + customerAgent.put(customer.getId(),customer.getAgentId()); + } + + List polices = readCsvFile(policiesFilePath, Policy.class); + Map agentPremiums = new HashMap<>(); + for(Policy policy: polices){ + int agentId = customerAgent.get(policy.getCustomerId()); + if(agentPremiums.containsKey(agentId)){ + double current = agentPremiums.get(agentId); + agentPremiums.put(agentId,current + policy.getPremiumPerMonth()); + } else { + agentPremiums.put(agentId,policy.getPremiumPerMonth()); + } + } + + + return agentPremiums; } } \ No newline at end of file From f7abc168309fd69c6664fb4e89f26ee2a6beac7f Mon Sep 17 00:00:00 2001 From: Levi506 Date: Sat, 15 Oct 2022 23:52:47 -0500 Subject: [PATCH 2/3] Commit .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b83d222 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target/ From 8a2223c39560551a5b7613f4dc81c98bec6d3f49 Mon Sep 17 00:00:00 2001 From: Levi506 Date: Sat, 15 Oct 2022 23:56:34 -0500 Subject: [PATCH 3/3] Commiting All Changes for Pull --- .classpath | 32 + .project | 34 ++ .settings/org.eclipse.jdt.core.prefs | 576 ++++++++++++++++++ .vscode/settings.json | 11 + feedback.txt | 8 +- pom.xml | 19 +- .../simpledatatool/Application.java | 20 +- .../controller/SimpleDataToolController.java | 16 +- .../simpledatatool/sql/DataCore.java | 150 +++++ .../sql/utility/SqlConnector.java | 28 + src/main/resources/DDL.sql | 4 + statefarm.db | Bin 0 -> 86016 bytes 12 files changed, 889 insertions(+), 9 deletions(-) create mode 100644 .classpath create mode 100644 .project create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .vscode/settings.json create mode 100644 src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/DataCore.java create mode 100644 src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/utility/SqlConnector.java create mode 100644 src/main/resources/DDL.sql create mode 100644 statefarm.db diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..83a3b6f --- /dev/null +++ b/.classpath @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..18aed47 --- /dev/null +++ b/.project @@ -0,0 +1,34 @@ + + + 2022-StateFarm-CodingCompetitionProblem + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + + + 1665891825525 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..3c275d4 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,576 @@ +eclipse.preferences.version=1 +enableParallelJavaIndexSearch=true +org.eclipse.jdt.core.builder.annotationPath.allLocations=disabled +org.eclipse.jdt.core.builder.cleanOutputFolder=clean +org.eclipse.jdt.core.builder.duplicateResourceTask=warning +org.eclipse.jdt.core.builder.invalidClasspath=abort +org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder=ignore +org.eclipse.jdt.core.builder.resourceCopyExclusionFilter= +org.eclipse.jdt.core.circularClasspath=warning +org.eclipse.jdt.core.classpath.exclusionPatterns=enabled +org.eclipse.jdt.core.classpath.mainOnlyProjectHasTestOnlyDependency=error +org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled +org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource=error +org.eclipse.jdt.core.codeComplete.argumentPrefixes= +org.eclipse.jdt.core.codeComplete.argumentSuffixes= +org.eclipse.jdt.core.codeComplete.camelCaseMatch=enabled +org.eclipse.jdt.core.codeComplete.deprecationCheck=disabled +org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck=disabled +org.eclipse.jdt.core.codeComplete.fieldPrefixes= +org.eclipse.jdt.core.codeComplete.fieldSuffixes= +org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck=enabled +org.eclipse.jdt.core.codeComplete.forceImplicitQualification=disabled +org.eclipse.jdt.core.codeComplete.localPrefixes= +org.eclipse.jdt.core.codeComplete.localSuffixes= +org.eclipse.jdt.core.codeComplete.staticFieldPrefixes= +org.eclipse.jdt.core.codeComplete.staticFieldSuffixes= +org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes= +org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes= +org.eclipse.jdt.core.codeComplete.subwordMatch=disabled +org.eclipse.jdt.core.codeComplete.suggestStaticImports=enabled +org.eclipse.jdt.core.codeComplete.visibilityCheck=enabled +org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=disabled +org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore +org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull +org.eclipse.jdt.core.compiler.annotation.nonnull.secondary= +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary= +org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable +org.eclipse.jdt.core.compiler.annotation.nullable.secondary= +org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.lambda.genericSignature=do not generate +org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate +org.eclipse.jdt.core.compiler.codegen.shareCommonFinallyBlocks=disabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=17 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.doc.comment.support=enabled +org.eclipse.jdt.core.compiler.emulateJavacBug8031744=enabled +org.eclipse.jdt.core.compiler.generateClassFiles=enabled +org.eclipse.jdt.core.compiler.maxProblemPerUnit=100 +org.eclipse.jdt.core.compiler.problem.APILeak=warning +org.eclipse.jdt.core.compiler.problem.annotatedTypeArgumentToUnannotated=info +org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.autoboxing=ignore +org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning +org.eclipse.jdt.core.compiler.problem.deadCode=warning +org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement=disabled +org.eclipse.jdt.core.compiler.problem.deprecation=warning +org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled +org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled +org.eclipse.jdt.core.compiler.problem.discouragedReference=warning +org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore +org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore +org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled +org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore +org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning +org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning +org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled +org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning +org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning +org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore +org.eclipse.jdt.core.compiler.problem.invalidJavadoc=ignore +org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=public +org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore +org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning +org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore +org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled +org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public +org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag +org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=public +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled +org.eclipse.jdt.core.compiler.problem.missingSerialVersion=ignore +org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore +org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning +org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning +org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore +org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning +org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation=warning +org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error +org.eclipse.jdt.core.compiler.problem.nullReference=warning +org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error +org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning +org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation=ignore +org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning +org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore +org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning +org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore +org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore +org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning +org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning +org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore +org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore +org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning +org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore +org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore +org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled +org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning +org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled +org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled +org.eclipse.jdt.core.compiler.problem.suppressWarningsNotFullyAnalysed=info +org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields=disabled +org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore +org.eclipse.jdt.core.compiler.problem.tasks=warning +org.eclipse.jdt.core.compiler.problem.terminalDeprecation=warning +org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning +org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled +org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning +org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning +org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore +org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=ignore +org.eclipse.jdt.core.compiler.problem.uninternedIdentityComparison=disabled +org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType=warning +org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict=disabled +org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType=info +org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore +org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore +org.eclipse.jdt.core.compiler.problem.unstableAutoModuleName=warning +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled +org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedImport=warning +org.eclipse.jdt.core.compiler.problem.unusedLabel=warning +org.eclipse.jdt.core.compiler.problem.unusedLocal=warning +org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled +org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning +org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation=warning +org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning +org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning +org.eclipse.jdt.core.compiler.processAnnotations=disabled +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=17 +org.eclipse.jdt.core.compiler.storeAnnotations=disabled +org.eclipse.jdt.core.compiler.taskCaseSensitive=enabled +org.eclipse.jdt.core.compiler.taskPriorities=NORMAL,HIGH,NORMAL +org.eclipse.jdt.core.compiler.taskTags=TODO,FIXME,XXX +org.eclipse.jdt.core.computeJavaBuildOrder=ignore +org.eclipse.jdt.core.encoding=utf8 +org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false +org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647 +org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line=true +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false +org.eclipse.jdt.core.formatter.align_with_spaces=false +org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_enum_constant=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_field=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_method=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_package=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_parameter=0 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_type=49 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assertion_message=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain=0 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_arrow=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon=16 +org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0 +org.eclipse.jdt.core.formatter.alignment_for_module_statements=16 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_record_components=16 +org.eclipse.jdt.core.formatter.alignment_for_relational_operator=0 +org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_shift_operator=0 +org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16 +org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_switch_case_with_arrow=20 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_type_annotations=0 +org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0 +org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0 +org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=0 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch=0 +org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1 +org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_record_constructor=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_record_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped=true +org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=true +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false +org.eclipse.jdt.core.formatter.comment.indent_root_tags=false +org.eclipse.jdt.core.formatter.comment.indent_tag_description=false +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags=do not insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true +org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true +org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off +org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=false +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true +org.eclipse.jdt.core.formatter.indentation.size=4 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default=insert +org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_permitted_types=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_not_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert +org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case=insert +org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default=insert +org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_permitted_types=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.join_lines_in_comments=false +org.eclipse.jdt.core.formatter.join_wrapped_lines=false +org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_code_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false +org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false +org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_method_body_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line=false +org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_switch_case_with_arrow_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.lineSplit=120 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines +org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true +org.eclipse.jdt.core.formatter.tabulation.char=space +org.eclipse.jdt.core.formatter.tabulation.size=4 +org.eclipse.jdt.core.formatter.text_block_indentation=0 +org.eclipse.jdt.core.formatter.use_on_off_tags=true +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true +org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator=true +org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false +org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true +org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true +org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true +org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true +org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true +org.eclipse.jdt.core.formatter.wrap_before_relational_operator=true +org.eclipse.jdt.core.formatter.wrap_before_shift_operator=true +org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true +org.eclipse.jdt.core.formatter.wrap_before_switch_case_arrow_operator=false +org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true +org.eclipse.jdt.core.incompatibleJDKLevel=ignore +org.eclipse.jdt.core.incompleteClasspath=error +org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter +org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc=50 diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..2f4fbe0 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,11 @@ +{ + "sqltools.connections": [ + { + "previewLimit": 50, + "driver": "SQLite", + "database": "${workspaceFolder:2022-StateFarm-CodingCompetitionProblem}/statefarm.db", + "name": "SFCC2022" + } + ], + "sqltools.useNodeRuntime": true +} \ No newline at end of file diff --git a/feedback.txt b/feedback.txt index b931d50..9853da9 100644 --- a/feedback.txt +++ b/feedback.txt @@ -1,9 +1,9 @@ -Your team (name of each individual participating): -How many JUnits were you able to get to pass? +Your team (name of each individual participating):Levi Bottomley +How many JUnits were you able to get to pass? 10 Document and describe any enhancements included to help the judges properly grade your submission. - Step 1: - Step 2: + Step 1: There was an in-progress to allow the software to move the csv data into a sql database through template inserts and using the skeletons methods. + Step 2: DDL for generating Database for existing Models added to resources Feedback for the coding competition? Things you would like to see in future events? diff --git a/pom.xml b/pom.xml index 63e8853..635501c 100644 --- a/pom.xml +++ b/pom.xml @@ -8,11 +8,26 @@ 1.0-SNAPSHOT - 1.8 - 1.8 + 17 + 17 + + + org.xerial + sqlite-jdbc + 3.39.3.0 + + + + + org.openjfx + javafx + 20-ea+4 + pom + + junit junit diff --git a/src/main/java/com/statefarm/codingcompetition/simpledatatool/Application.java b/src/main/java/com/statefarm/codingcompetition/simpledatatool/Application.java index d2638f0..fc6897c 100644 --- a/src/main/java/com/statefarm/codingcompetition/simpledatatool/Application.java +++ b/src/main/java/com/statefarm/codingcompetition/simpledatatool/Application.java @@ -1,7 +1,25 @@ package com.statefarm.codingcompetition.simpledatatool; +import java.util.LinkedList; +import java.util.List; + +import com.statefarm.codingcompetition.simpledatatool.sql.DataCore; +import com.statefarm.codingcompetition.simpledatatool.sql.utility.SqlConnector; + public class Application { public static void main(String[] args) { - System.out.println("Hello World"); + List cleanArgs = new LinkedList(); + for(String arg: args){ + cleanArgs.add(arg); + } + DataCore dataManager = new DataCore(); + SqlConnector.setConnectionString("jdbc:sqlite:statefarm.db"); + + if(cleanArgs.contains("-genDB")||true){ + dataManager.generateDatabase(); + }; + + + } } diff --git a/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java b/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java index 4f0113f..7105488 100644 --- a/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java +++ b/src/main/java/com/statefarm/codingcompetition/simpledatatool/controller/SimpleDataToolController.java @@ -30,6 +30,7 @@ public List readCsvFile(String filePath, Class classType) { try{ File file = new File(filePath); + //Using the lib that was already in the project CsvMapper mapper = new CsvMapper(); mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); CsvSchema Schema = CsvSchema.emptySchema().withHeader(); @@ -93,7 +94,7 @@ public int getNumberOfAgentsForState(String filePath, String state) { * @return float of monthly premium */ public double sumMonthlyPremiumForCustomerId(List policies, int customerId) { - //Copy the given List as all situations this method is used it needs to be untouched + //Copy the given List as all situations this method is used the original List needs to remain consistent List policiesCopy = new LinkedList<>(policies); policiesCopy.removeIf(p -> p.getCustomerId() != customerId); double policyTotal = 0d; @@ -119,21 +120,27 @@ public Integer getNumberOfOpenClaimsForCustomerName(String filePathToCustomer, S List cust = readCsvFile(filePathToCustomer, Customer.class); + cust.removeIf(c-> !c.getFirstName().equals(firstName)); cust.removeIf(c -> !c.getLastName().equals(lastName)); if(cust.size() == 0){ return null; } + + Customer customer = cust.get(0); List policies = readCsvFile(filePathToPolicy, Policy.class); + policies.removeIf(p -> p.getCustomerId() != customer.getId()); List policyIds = new LinkedList<>(); + for(Policy p : policies){ policyIds.add(p.getId()); } List claims = readCsvFile(filePathToClaims, Claim.class); + claims.removeIf(claim -> !policyIds.contains(claim.getPolicyId())); claims.removeIf(claim -> !claim.getIsClaimOpen()); @@ -150,8 +157,11 @@ public Integer getNumberOfOpenClaimsForCustomerName(String filePathToCustomer, S * @return String of language */ public String getMostSpokenLanguageForState(String customersFilePath, String state) { + List cust = readCsvFile(customersFilePath, Customer.class); + Map languageSpeakers = new HashMap<>(); + cust.removeIf(c-> !c.getState().equals(state)); for(Customer customer: cust){ @@ -176,7 +186,7 @@ public String getMostSpokenLanguageForState(String customersFilePath, String sta * Helper method for getMostSpokenLanguageForState * * @param languageSpeakers State abbreviation String - * @param language + * @param language English String for Langauge */ private void languageSpeakersHelper(Map languageSpeakers,String language){ if(languageSpeakers.containsKey(language)){ @@ -199,9 +209,11 @@ public Customer getCustomerWithHighestTotalPremium(String customersFilePath, Lis List cust = readCsvFile(customersFilePath, Customer.class); Map premiumTotals = new HashMap<>(); for(Customer customer : cust){ + //Subtract by 1 to fill 0 index to prevent slide premiumTotals.put(customer.getId() - 1, sumMonthlyPremiumForCustomerId(policies, customer.getId())); } List keys = new LinkedList(premiumTotals.keySet()); + keys.sort((k1,k2) -> (int)(Math.ceil(premiumTotals.get(k2)) - Math.ceil(premiumTotals.get(k1)))); return cust.get(keys.get(0)); diff --git a/src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/DataCore.java b/src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/DataCore.java new file mode 100644 index 0000000..52dba34 --- /dev/null +++ b/src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/DataCore.java @@ -0,0 +1,150 @@ +package com.statefarm.codingcompetition.simpledatatool.sql; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Statement; +import java.text.DateFormat; +import java.util.LinkedList; +import java.util.List; +import java.util.Scanner; + +import com.statefarm.codingcompetition.simpledatatool.controller.SimpleDataToolController; +import com.statefarm.codingcompetition.simpledatatool.model.Agent; +import com.statefarm.codingcompetition.simpledatatool.model.Customer; +import com.statefarm.codingcompetition.simpledatatool.sql.utility.SqlConnector; + + +/** + * Class for mangeing Database Processing + */ +public class DataCore { + + //Path to DDL for design + private static String DDLPath = "src/main/resources/DDL.sql"; + + + //CSV Paths + private final String agentsFilePath = "src/main/resources/agents.csv"; + private final String claimsFilePath = "src/main/resources/claims.csv"; + private final String customersFilePath = "src/main/resources/customers.csv"; + private final String policiesFilePath = "src/main/resources/policies.csv"; + + //SimpleDataTool for CSV Import + private SimpleDataToolController dataToolController; + + //Template Insert Strings + private final String agentInsert = "REPLACE INTO agent (id,first_name,last_name,'state',region,pri_lang,sec_lang) VALUES (%d,\"%s\",\"%s\",\"%s\",\"%s\") "; + private final String customerInsert = "REPLACE INTO customer (id,first_name,last_name,'state',region,agent_id,pri_lang,sec_lang) VALUES (%d,\"%s\",\"%s\",\"%s\",\"%s\",%d,%s,\"%s\")"; + private final String policyInsert = "REPLACE INTO 'policy' (id,customer_id,startDate,premiumPerMonth) VALUES (%d,%d,%d,%f)"; + private final String claimInsert = "REPLACE INTO claim (id,customer_id,startDate,premiumPerMonth) VALUES (%d,%d,%d,%f)"; + //private SimpleDateFormat DateFormat; + + public DataCore(){ + //Create and instance of the Simple Data tool to pull the CSVs + dataToolController = new SimpleDataToolController(); + //DateFormat = new SimpleDateFormat("MM/DD/YYYY") + } + + /**Method to use the DDL in Resources to generate the Tables for the database and then call helper methods to to use the insert strings to push CSV data to the DB + * + */ + public void generateDatabase() { + Connection dbConnection = SqlConnector.createConnection(); + + + try{ + File DDLFile = new File(DDLPath); + Scanner reader = new Scanner(DDLFile); + + Statement statement = dbConnection.createStatement(); + statement.setQueryTimeout(30); + while(reader.hasNext()){ + statement.addBatch(reader.nextLine()); + statement.executeBatch(); + } + generateAgentDB(dbConnection); + generateCustomerDB(dbConnection); + + //Closing to prevent Memory Leaks + reader.close(); + dbConnection.close(); + + } catch(Exception e ){ + e.printStackTrace(); + } + } + + + /** + * Helper Method for generating AgentDB + * @param dbConnection Active Database connection + */ + private void generateAgentDB(Connection dbConnection){ + try{ + List agents = dataToolController.readCsvFile(agentsFilePath,Agent.class); + Statement state = dbConnection.createStatement(); + state.setQueryTimeout(30); + + for(Agent agent: agents){ + state.execute(String.format(agentInsert, agent.getId(),agent.getFirstName(),agent.getLastName(),agent.getState(),agent.getRegion(),agent.getPrimaryLanguage(),agent.getSecondaryLanguage())); + } + state.close(); + } catch (SQLException e){ + e.printStackTrace(); + } + + } + + /** + * Helper Method for generating CustomerDB + * @param dbConnection Active Database connection + */ + private void generateCustomerDB(Connection dbConnection){ + try{List cust = dataToolController.readCsvFile(customersFilePath,Customer.class); + Statement state = dbConnection.createStatement(); + state.setQueryTimeout(30); + for(Customer customer: cust){ + state.execute(String.format(customerInsert, customer.getId(),customer.getFirstName(),customer.getLastName(),customer.getState(),customer.getRegion(),customer.getAgentId(),customer.getPrimaryLanguage(),customer.getSecondaryLanguage())); + } + + state.close(); + } catch (SQLException e){ + e.printStackTrace(); + } + + } + /* + private void generatePolicyDB(Connection dbConnect){ + try{List policy = dataToolController.readCsvFile(customersFilePath,Customer.class); + Statement state = dbConnection.createStatement(); + state.setQueryTimeout(30); + for(Policy customer: cust){ + state.addBatch(String.format(policyInsert, customer.getId(),customer.getFirstName(),customer.getLastName(),customer.getState(),customer.getRegion(),customer.getAgentId(),customer.getPrimaryLanguage(),customer.getSecondaryLanguage())); + } + state.executeBatch(); + + state.close(); + } catch (SQLException e){ + e.printStackTrace(); + } + } + + private generateClaimDB(Connection dbConnection){ + try{List cust = dataToolController.readCsvFile(customersFilePath,Customer.class); + Statement state = dbConnection.createStatement(); + state.setQueryTimeout(30); + for(Claim claim: cust){ + state.addBatch(String.format(claimInsert, )); + } + state.executeBatch(); + + state.close(); + } catch (SQLException e){ + e.printStackTrace(); + } + } + */ +} diff --git a/src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/utility/SqlConnector.java b/src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/utility/SqlConnector.java new file mode 100644 index 0000000..4a56dd7 --- /dev/null +++ b/src/main/java/com/statefarm/codingcompetition/simpledatatool/sql/utility/SqlConnector.java @@ -0,0 +1,28 @@ +package com.statefarm.codingcompetition.simpledatatool.sql.utility; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + + +/**Helper Class for creating SQL Connections + * + */ +public class SqlConnector { + + //This variable is set to be unreadibe outside of the class for security reasons; + private static String connectionString; + + + public static Connection createConnection(){ + try{ + return DriverManager.getConnection(connectionString); + } catch (SQLException e){ + return null; + } + } + + public static void setConnectionString(String connString){ + connectionString = connString; + } +} diff --git a/src/main/resources/DDL.sql b/src/main/resources/DDL.sql new file mode 100644 index 0000000..a44e485 --- /dev/null +++ b/src/main/resources/DDL.sql @@ -0,0 +1,4 @@ +CREATE TABLE IF NOT EXISTS agent ( id INT NOT NULL, first_name VARCHAR(50) NOT NULL, last_name VARCHAR(50) NOT NULL, 'state' VARCHAR(2) NOT NULL, region VARCHAR(20) NOT NULL,pri_lang VARCHAR(20),sec_lang VARCHAR(20), PRIMARY KEY (id)); +CREATE TABLE IF NOT EXISTS customer ( id INT NOT NULL, agent_id INT, first_name VARCHAR(50) NOT NULL, last_name VARCHAR(50) NOT NULL, 'state' VARCHAR(2) NOT NULL, region INT NOT NULL,pri_lang VARCHAR(20),sec_lang VARCHAR(20),PRIMARY KEY (id),FOREIGN KEY(agent_id) REFERENCES agent(id)); +CREATE TABLE IF NOT EXISTS 'policy'(id INT NOT NULL, customer_id INT ,startDate DATETIME NOT NULL,premiumPerMonth FLOAT NOT NULL,PRIMARY KEY(id),FOREIGN KEY(customer_id) REFERENCES customer(id)); +CREATE TABLE IF NOT EXISTS claim(id INT NOT NULL, policy_id INT ,claim_type VARCHAR(20),claim_open BOOLEAN,PRIMARY KEY (id),FOREIGN KEY(policy_id) REFERENCES 'policy'(id) ); \ No newline at end of file diff --git a/statefarm.db b/statefarm.db new file mode 100644 index 0000000000000000000000000000000000000000..5ccb344c46cd89b956de62705cf14683988e8652 GIT binary patch literal 86016 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 Vo4@(S{`J!@&tE_NfBV<2{x5z5dsF}b literal 0 HcmV?d00001