Vet Due date, FilingAction, and FilingDoc

proxyserver/src/main/java/edu/suffolk/litlab/efsp/docassemble/FilingDocDocassembleJacksonDeserializer.java

@@ -56,6 +56,7 @@ public static Optional<FilingDoc> fromNode(
       Map<String, PartyId> varToPartyId,
       int sequenceNum,
       List<FilingCode> filingOptions,
+      boolean isInitialFiling,
       CodesParser parser,
       InfoCollector collector)
       throws FilingError {
@@ -115,10 +116,25 @@ public static Optional<FilingDoc> fromNode(
       maybeDueDate =
           Optional.of(
               LocalDate.ofInstant(
-                  // TODO(brycew): why do we even pass this as a date time? Shouldn't it just be a
+                  // TODO(#47): why do we even pass this as a date time? Shouldn't it just be a
                   // date?
                   Instant.parse(jsonDueDate.asText()), ZoneId.of("America/Chicago")));
     }
+    var dueDateRes = parser.vetDueDate(maybeDueDate, filingType);
+    Optional<LocalDate> dueDate;
+    if (dueDateRes.isErr()) {
+      collector.addWrong(
+          collector
+              .varBuilder()
+              .name("due_date")
+              .datatype("date")
+              .appendDesc("The due date of the filing, some number of days after the filing.")
+              .build());
+      dueDate = maybeDueDate;
+    } else {
+      dueDate = dueDateRes.expect("");
+    }
+
     String userDescription = getStringDefault(node, "filing_description", "");
     var filingRefNum = unwrap(parser::vetFilingRefNum, node, "reference_number", collector);
     Optional<String> filingAttorney =
@@ -132,23 +148,33 @@ public static Optional<FilingDoc> fromNode(
     List<String> preliminaryCopies = getMemberList(node, "preliminary_copies");
     List<String> filingParties = getMemberList(node, "filing_parties");
 
-    Optional<String> actionStr = getStringMember(node, "filing_action");
+    String actionStr = getStringDefault(node, "filing_action", "");
+    Optional<FilingAction> maybeAction =
+        switch (actionStr.toLowerCase()) {
+          case "e_file" -> Optional.of(FilingAction.E_FILE);
+          case "efile" -> Optional.of(FilingAction.E_FILE);
+          case "e_file_and_serve" -> Optional.of(FilingAction.E_FILE_AND_SERVE);
+          case "efile_and_serve" -> Optional.of(FilingAction.E_FILE_AND_SERVE);
+          case "serve" -> Optional.of(FilingAction.SERVE);
+          default -> {
+            log.warn("Action {} isn't allowed, using default action for the operation", actionStr);
+            yield Optional.empty();
+          }
+        };
+    var actionRes = parser.vetFilingAction(maybeAction, isInitialFiling);
+    if (actionRes.isErr()) {
+      collector.addWrong(
+          collector
+              .varBuilder()
+              .name("filing_action")
+              .appendDesc(actionRes.expectErr("").reason())
+              .build());
+    }
     Optional<FilingAction> action = Optional.empty();
-    if (actionStr.isPresent()) {
-      String s = actionStr.get();
-      if (s.equalsIgnoreCase("e_file") || s.equalsIgnoreCase("efile")) {
-        action = Optional.of(FilingAction.E_FILE);
-      } else if (s.equalsIgnoreCase("efile_and_serve") || s.equalsIgnoreCase("e_file_and_serve")) {
-        action = Optional.of(FilingAction.E_FILE_AND_SERVE);
-      } else if (s.equalsIgnoreCase("serve")) {
-        action = Optional.of(FilingAction.SERVE);
-      } else {
-        log.warn(
-            "Filing Action "
-                + s
-                + " isn't an allowed action, defaulting to default action for the operation");
-      }
+    if (actionRes.isOk()) {
+      action = actionRes.expect("");
     }
+
     List<PartyId> fullParties =
         filingParties.stream()
             .map(
@@ -215,7 +241,7 @@ public static Optional<FilingDoc> fromNode(
             userDescription,
             descriptionFromSpec,
             filingRefNum,
-            maybeDueDate,
+            dueDate,
             fullParties,
             filingAttorney,
             goodAttachments.some(),

proxyserver/src/main/java/edu/suffolk/litlab/efsp/docassemble/FilingInformationDocassembleJacksonDeserializer.java

@@ -318,6 +318,7 @@ public FilingInformation fromNode(JsonNode node, InfoCollector collector) throws
             node.get("comments_to_clerk"),
             varToPartyId,
             filingOptions,
+            isInitialFiling,
             parser,
             collector));
     if (entities.getFilings().isEmpty()) {
@@ -515,6 +516,7 @@ private static List<FilingDoc> extractFilingDocs(
       JsonNode clerkComments,
       Map<String, PartyId> varToPartyId,
       List<FilingCode> filingOptions,
+      boolean isInitialFiling,
       CodesParser parser,
       InfoCollector collector)
       throws FilingError {
@@ -540,7 +542,13 @@ private static List<FilingDoc> extractFilingDocs(
         collector.pushAttributeStack("al_court_bundle.elements[" + i + "]");
         Optional<FilingDoc> maybeDoc =
             FilingDocDocassembleJacksonDeserializer.fromNode(
-                elems.get(i), varToPartyId, filingDocs.size(), filingOptions, parser, collector);
+                elems.get(i),
+                varToPartyId,
+                filingDocs.size(),
+                filingOptions,
+                isInitialFiling,
+                parser,
+                collector);
         collector.popAttributeStack();
         maybeDoc.ifPresent(
             doc -> {

proxyserver/src/main/java/edu/suffolk/litlab/efsp/server/ecf4/CodesParser.java

@@ -1,5 +1,6 @@
 package edu.suffolk.litlab.efsp.server.ecf4;
 
+import com.hubspot.algebra.NullValue;
 import com.hubspot.algebra.Result;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.CaseCategory;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.CaseType;
@@ -8,13 +9,16 @@
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.FilingCode;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.FilingComponent;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.NameAndCode;
+import edu.suffolk.litlab.efsp.model.FilingAction;
+import edu.suffolk.litlab.efsp.model.FilingDoc;
 import edu.suffolk.litlab.efsp.model.OptionalService;
 import edu.suffolk.litlab.efsp.model.PartyId;
 import edu.suffolk.litlab.efsp.model.PartyInfo;
 import edu.suffolk.litlab.efsp.model.Person;
 import edu.suffolk.litlab.efsp.model.Person.Gender;
 import edu.suffolk.litlab.efsp.utils.FilingError;
 import java.math.BigDecimal;
+import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -45,9 +49,17 @@ public sealed interface AttorneyError {}
   public record NoMultipleAttorneys() implements AttorneyError {}
   public record RequiredAttorneys() implements AttorneyError {}
 
+  public record DueDateRequired() {}
+
+  public record InvalidFilingAction(String reason) {}
+
   public sealed interface FileNameError {}
   public record FileExtensionNotAllowed(String given, List<FileType> allowed) implements FileNameError {}
   public record FileNameTextError(TextVarError err) implements FileNameError {}
+
+  public sealed interface FilingDocError {}
+  public record DocTooBig(int idx) implements FilingDocError {}
+  public record CumulativeDocsTooBig(long cumulativeBytes) implements FilingDocError {}
   // spotless:on
 
   // Methods
@@ -127,8 +139,16 @@ public Result<Optional<Map<PartyId, List<String>>>, AttorneyError> vetPartyAttor
 
   public Result<Optional<String>, TextVarError> vetComment(Optional<String> comment);
 
+  public Result<Optional<LocalDate>, DueDateRequired> vetDueDate(
+      Optional<LocalDate> dueDate, FilingCode filing);
+
+  public Result<Optional<FilingAction>, InvalidFilingAction> vetFilingAction(
+      Optional<FilingAction> filingAction, boolean isInitialFiling);
+
   public Optional<String> getDocumentDescription(
       String description, String firstFileName, FilingCode filing);
 
   public Result<String, FileNameError> vetFileName(String fileName);
+
+  public Result<NullValue, FilingDocError> vetFilingDocSize(List<FilingDoc> docs);
 }

proxyserver/src/main/java/edu/suffolk/litlab/efsp/server/ecf4/EcfCourtSpecificSerializer.java

@@ -325,7 +325,6 @@ public JAXBElement<DocumentType> filingDocToXml(
       CaseCategory caseCategory,
       CaseType motionType,
       FilingCode filing,
-      boolean isIndividual,
       JsonNode miscInfo,
       InfoCollector collector)
       throws IOException, FilingError {
@@ -342,20 +341,12 @@ public JAXBElement<DocumentType> filingDocToXml(
               docType.setDocumentFileControlID(Ecf4Helper.convertString(refNum));
             });
 
-    DataFieldRow dueDateRow = allDataFields.getFieldRow("DueDateAvailableForFilers");
-    if (filing.useduedate && dueDateRow.isvisible) {
-      if (doc.getDueDate().isPresent()) {
-        DateType cutOffDate = Ecf4Helper.convertDate(doc.getDueDate().get());
-        docType.setDocumentInformationCutOffDate(cutOffDate);
-      } else if (dueDateRow.isrequired) {
-        InterviewVariable var =
-            collector.requestVar(
-                "due_date",
-                "The due date of the filing, some number of days after the filing.",
-                "date");
-        collector.addRequired(var);
-      }
-    }
+    doc.getDueDate()
+        .ifPresent(
+            dueDate -> {
+              DateType cutOffDate = Ecf4Helper.convertDate(dueDate);
+              docType.setDocumentInformationCutOffDate(cutOffDate);
+            });
 
     docType.setDocumentSequenceID(Ecf4Helper.convertString(Integer.toString(doc.sequenceNum())));
 

proxyserver/src/main/java/edu/suffolk/litlab/efsp/server/ecf4/tyler/TylerCodesParser.java

@@ -1,6 +1,9 @@
 package edu.suffolk.litlab.efsp.server.ecf4.tyler;
 
+import com.hubspot.algebra.NullValue;
 import com.hubspot.algebra.Result;
+import ecf4.latest.gov.niem.niem.niem_core._2.MeasureType;
+import ecf4.latest.oasis.names.tc.legalxml_courtfiling.schema.xsd.courtpolicyresponsemessage_4.DevelopmentPolicyParametersType;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.CaseCategory;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.CaseType;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.CodeDatabase;
@@ -15,13 +18,17 @@
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.NameAndCode;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.OptionalServiceCode;
 import edu.suffolk.litlab.efsp.ecfcodes.tyler.PartyType;
+import edu.suffolk.litlab.efsp.model.FilingAction;
+import edu.suffolk.litlab.efsp.model.FilingDoc;
 import edu.suffolk.litlab.efsp.model.OptionalService;
 import edu.suffolk.litlab.efsp.model.PartyId;
 import edu.suffolk.litlab.efsp.model.PartyInfo;
 import edu.suffolk.litlab.efsp.model.Person;
 import edu.suffolk.litlab.efsp.model.Person.Gender;
 import edu.suffolk.litlab.efsp.server.ecf4.CodesParser;
+import edu.suffolk.litlab.efsp.server.ecf4.Ecf4Helper;
 import edu.suffolk.litlab.efsp.utils.FilingError;
+import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -46,25 +53,38 @@ public class TylerCodesParser implements CodesParser {
   private static Logger log = LoggerFactory.getLogger(TylerCodesParser.class);
   private final CodeDatabase cd;
   private final CourtLocationInfo court;
+  private final DevelopmentPolicyParametersType policy;
   private final DataFields allDataFields;
   private final boolean isIndividual;
 
   public TylerCodesParser(
-      CodeDatabase cd, CourtLocationInfo court, DataFields allDataFields, boolean isIndividual) {
+      CodeDatabase cd,
+      DevelopmentPolicyParametersType policy,
+      CourtLocationInfo court,
+      DataFields allDataFields,
+      boolean isIndividual) {
     this.cd = cd;
     this.court = court;
+    this.policy = policy;
     this.allDataFields = allDataFields;
     this.isIndividual = isIndividual;
   }
 
-  public TylerCodesParser(CodeDatabase cd, CourtLocationInfo court, boolean isIndividual) {
-    this(cd, court, cd.getDataFields(court.code), isIndividual);
+  public TylerCodesParser(
+      CodeDatabase cd,
+      DevelopmentPolicyParametersType policy,
+      CourtLocationInfo court,
+      boolean isIndividual) {
+    this(cd, policy, court, cd.getDataFields(court.code), isIndividual);
   }
 
   public static Optional<CodesParser> makeParser(
-      CodeDatabase cd, String courtId, boolean isIndividual) {
+      CodeDatabase cd,
+      DevelopmentPolicyParametersType policy,
+      String courtId,
+      boolean isIndividual) {
     Optional<CourtLocationInfo> locationInfo = cd.getFullLocationInfo(courtId);
-    return locationInfo.map(li -> new TylerCodesParser(cd, li, isIndividual));
+    return locationInfo.map(li -> new TylerCodesParser(cd, policy, li, isIndividual));
   }
 
   /////////////////// Methods that access the codes database.
@@ -578,11 +598,6 @@ public Result<Optional<NameAndCode>, CodeError> vetDamageAmount(
   }
 
   ////////  Still TODO
-  // Attorney: Party Attorney and Filing Attorney
-  // FileName
-  // DueDate
-  // Filing Action
-  // Filing Doc
   // Filer Types
   // Filing Associations
   // Anything else not currently checked
@@ -825,6 +840,41 @@ public Result<Optional<String>, TextVarError> vetComment(Optional<String> maybeC
     return Result.ok(Optional.empty());
   }
 
+  public Result<Optional<LocalDate>, DueDateRequired> vetDueDate(
+      Optional<LocalDate> dueDate, FilingCode filing) {
+    DataFieldRow dueDateRow = allDataFields.getFieldRow("DueDateAvailableForFilers");
+    if (filing.useduedate && dueDateRow.isvisible) {
+      if (dueDate.isEmpty() && dueDateRow.isrequired) {
+        return Result.err(new DueDateRequired());
+      }
+      return Result.ok(dueDate);
+    }
+    return Result.ok(Optional.empty());
+  }
+
+  public Result<Optional<FilingAction>, InvalidFilingAction> vetFilingAction(
+      Optional<FilingAction> filingAction, boolean isInitialFiling) {
+    // From Reference Guide: if no FilingAction is provided, the original default behavior applies:
+    // * ReviewFiling API w/o service contacts: EFile
+    // * ReviewFiling API w/ service contacts: EfileAndServe
+    // * ServeFiling API: Serve
+    if (filingAction.isPresent()) {
+      FilingAction act = filingAction.get();
+      boolean serviceOnInitial =
+          switch (this.court.allowserviceoninitial) {
+            case TRUE -> true;
+            case FALSE -> false;
+            case DEFAULT -> allDataFields.getFieldRow("FilingServiceCheckBoxInitial").isvisible;
+          };
+      if (isInitialFiling
+          && !serviceOnInitial
+          && (act.equals(FilingAction.E_FILE_AND_SERVE) || act.equals(FilingAction.SERVE))) {
+        return Result.err(new InvalidFilingAction("Cannot do service on initial filing"));
+      }
+    }
+    return Result.ok(filingAction);
+  }
+
   public Optional<String> getDocumentDescription(
       String description, String firstFileName, FilingCode filing) {
     DataFieldRow row = allDataFields.getFieldRow("DocumentDescription");
@@ -868,4 +918,24 @@ public Result<String, FileNameError> vetFileName(String fileName) {
     }
     return Result.ok(fileName);
   }
+
+  public Result<NullValue, FilingDocError> vetFilingDocSize(List<FilingDoc> docs) {
+    MeasureType maxIndivDocSize = policy.getMaximumAllowedAttachmentSize();
+    long maxEach = Ecf4Helper.sizeMeasureAsBytes(maxIndivDocSize);
+    long cumulativeBytes = 0;
+    for (int i = 0; i < docs.size(); i++) {
+      var doc = docs.get(i);
+      long docSize = doc.allAttachmentsLength();
+      if (docSize > maxEach) {
+        return Result.err(new DocTooBig(i));
+      }
+      cumulativeBytes += docSize;
+    }
+    MeasureType maxTotalDocSize = policy.getMaximumAllowedMessageSize();
+    long maxTotal = Ecf4Helper.sizeMeasureAsBytes(maxTotalDocSize);
+    if (cumulativeBytes > maxTotal) {
+      return Result.err(new CumulativeDocsTooBig(cumulativeBytes));
+    }
+    return Result.nullOk();
+  }
 }