#754 Multiple Uploads (#763)

* Improve UX by replacing buttons with menu popover

* Perf improvement only watch for changes if a decryption is in progress

* Rename decryption to tally in UI

* Exclude duplicate ballots

* Show sum of ballots uploaded

* Show ballots uploaded and ballot count on decryption page

* Fix bug with ballot sum

* Some unit tests

* Added "Upload More Ballots" button

* Fix decryption reference

Author: lprichar

src/electionguard_gui/components/create_decryption_component.py

@@ -31,7 +31,7 @@ def get_suggested_decryption_name(self, election_id: str) -> dict[str, Any]:
             db, election_id
         )
         return eel_success(
-            f"{election.election_name} Decryption #{existing_decryptions + 1}"
+            f"{election.election_name} Tally #{existing_decryptions + 1}"
         )
 
     def create_decryption(

src/electionguard_gui/components/upload_ballots_component.py

@@ -29,7 +29,6 @@ def create_ballot_upload(
         election_id: str,
         device_file_name: str,
         device_file_contents: str,
-        ballot_count: int,
     ) -> dict[str, Any]:
         try:
             db = self._db_service.get_db()
@@ -43,15 +42,13 @@ def create_ballot_upload(
                 election_id,
                 device_file_name,
                 device_file_contents,
-                ballot_count,
                 created_at,
             )
             self._election_service.append_ballot_upload(
                 db,
                 election_id,
                 ballot_upload_id,
                 device_file_contents,
-                ballot_count,
                 created_at,
             )
             return eel_success(ballot_upload_id)
@@ -69,10 +66,15 @@ def upload_ballot(
         try:
             db = self._db_service.get_db()
             self._log.debug(f"adding ballot {file_name} to {ballot_upload_id}")
-            self._ballot_upload_service.add_ballot(
+            success = self._ballot_upload_service.add_ballot(
                 db, ballot_upload_id, election_id, file_name, file_contents
             )
-            return eel_success()
+            if success:
+                self._ballot_upload_service.increment_ballot_count(db, ballot_upload_id)
+                self._election_service.increment_ballot_upload_ballot_count(
+                    db, election_id, ballot_upload_id
+                )
+            return eel_success({"is_duplicate": not success})
         # pylint: disable=broad-except
         except Exception as e:
             return self.handle_error(e)

src/electionguard_gui/models/decryption_dto.py

@@ -41,6 +41,8 @@ class DecryptionDto:
     decryption_id: str
     election_id: str
     election_name: Optional[str]
+    ballot_upload_count: int
+    ballot_count: int
     guardians: int
     quorum: int
     decryption_name: Optional[str]
@@ -63,6 +65,8 @@ def __init__(self, decryption: dict[str, Any]):
         self.election_id = str(decryption.get("election_id"))
         self.key_ceremony_id = decryption.get("key_ceremony_id")
         self.election_name = decryption.get("election_name")
+        self.ballot_upload_count = _get_int(decryption, "ballot_upload_count", 0)
+        self.ballot_count = _get_int(decryption, "ballot_count", 0)
         self.guardians = _get_int(decryption, "guardians", 0)
         self.quorum = _get_int(decryption, "quorum", 0)
         self.decryption_name = decryption.get("decryption_name")
@@ -99,6 +103,8 @@ def to_dict(self) -> dict[str, Any]:
             "decryption_id": self.decryption_id,
             "election_id": self.election_id,
             "election_name": self.election_name,
+            "ballot_upload_count": self.ballot_upload_count,
+            "ballot_count": self.ballot_count,
             "decryption_name": self.decryption_name,
             "guardians_joined": self.guardians_joined,
             "status": self.get_status(),

src/electionguard_gui/models/election_dto.py

@@ -111,6 +111,9 @@ def get_guardian_sequence_order(self, guardian_id: str) -> int:
                 return record.sequence_order
         raise Exception("Guardian not found")
 
+    def sum_ballots(self) -> int:
+        return sum(ballot["ballot_count"] for ballot in self.ballot_uploads)
+
 
 def _get_list(election: dict[str, Any], name: str) -> list:
     value = election.get(name)

src/electionguard_gui/services/ballot_upload_service.py

@@ -25,14 +25,13 @@ def create(
         election_id: str,
         device_file_name: str,
         device_file_contents: str,
-        ballot_count: int,
         created_at: datetime,
     ) -> str:
         ballot_upload = {
             "election_id": election_id,
             "device_file_name": device_file_name,
             "device_file_contents": device_file_contents,
-            "ballot_count": ballot_count,
+            "ballot_count": 0,
             "created_by": self._auth_service.get_user_id(),
             "created_at": created_at,
         }
@@ -47,16 +46,41 @@ def add_ballot(
         election_id: str,
         file_name: str,
         file_contents: str,
-    ) -> None:
+    ) -> bool:
         self._log.trace(f"adding ballot {file_name} to {ballot_upload_id}")
+        ballot = from_raw(SubmittedBallot, file_contents)
+        ballot_object_id = ballot.object_id
+        if self.any_ballot_exists(db, election_id, ballot_object_id):
+            self._log.warn(
+                "ballot '{ballot_object_id}' already exists in election '{election_id}'"
+            )
+            return False
         db.ballot_uploads.insert_one(
             {
                 "ballot_upload_id": ballot_upload_id,
                 "election_id": election_id,
                 "file_name": file_name,
+                "object_id": ballot_object_id,
                 "file_contents": file_contents,
             }
         )
+        return True
+
+    def increment_ballot_count(self, db: Database, ballot_upload_id: str) -> None:
+        self._log.trace(f"incrementing ballot count for {ballot_upload_id}")
+        db.ballot_uploads.update_one(
+            {"_id": ballot_upload_id, "ballot_count": {"$exists": True}},
+            {"$inc": {"ballot_count": 1}},
+        )
+
+    def any_ballot_exists(self, db: Database, election_id: str, object_id: str) -> bool:
+        self._log.trace("checking if ballot exists for {election_id}")
+        return (
+            db.ballot_uploads.count_documents(
+                {"election_id": election_id, "object_id": object_id}
+            )
+            > 0
+        )
 
     def get_ballots(self, db: Database, election_id: str) -> list[SubmittedBallot]:
         self._log.debug(f"getting ballots for {election_id}")

src/electionguard_gui/services/decryption_service.py

@@ -39,9 +39,13 @@ def create(
         election: ElectionDto,
         decryption_name: str,
     ) -> str:
+        ballot_count = election.sum_ballots()
+        ballot_upload_count = len(election.ballot_uploads)
         decryption: dict[str, Any] = {
             "election_id": election.id,
             "election_name": election.election_name,
+            "ballot_count": ballot_count,
+            "ballot_upload_count": ballot_upload_count,
             "key_ceremony_id": election.key_ceremony_id,
             "guardians": election.guardians,
             "quorum": election.quorum,

src/electionguard_gui/services/election_service.py

@@ -89,7 +89,6 @@ def append_ballot_upload(
         election_id: str,
         ballot_upload_id: str,
         device_file_contents: str,
-        ballot_count: int,
         created_at: datetime,
     ) -> None:
         self._log.trace(
@@ -107,7 +106,7 @@ def append_ballot_upload(
                         "launch_code": device_file_json["launch_code"],
                         "location": device_file_json["location"],
                         "session_id": device_file_json["session_id"],
-                        "ballot_count": ballot_count,
+                        "ballot_count": 0,
                         "created_at": created_at,
                     }
                 }
@@ -124,3 +123,17 @@ def append_decryption(
             {"_id": ObjectId(election_id)},
             {"$push": {"decryptions": {"decryption_id": decryption_id, "name": name}}},
         )
+
+    def increment_ballot_upload_ballot_count(
+        self, db: Database, election_id: str, ballot_upload_id: str
+    ) -> None:
+        self._log.trace(
+            f"incrementing ballot upload {ballot_upload_id} ballot count in election {election_id}"
+        )
+        db.elections.update_one(
+            {
+                "_id": ObjectId(election_id),
+                "ballot_uploads.ballot_upload_id": ballot_upload_id,
+            },
+            {"$inc": {"ballot_uploads.$.ballot_count": 1}},
+        )

src/electionguard_gui/web/components/admin/create-decryption-component.js

@@ -43,10 +43,10 @@ export default {
     <form id="mainForm" class="needs-validation" novalidate @submit.prevent="createDecryption">
       <div class="row g-3 text-center col-6 mx-auto">
         <div class="col-12">
-          <h1>Create Decryption</h1>
+          <h1>Create Tally</h1>
         </div>
         <div class="col-12">
-          <label for="name" class="form-label">Decryption Name</label>
+          <label for="name" class="form-label">Name</label>
           <input type="text" id="name" class="form-control" v-model="name" required>
         </div>
         <div class="col-12 mt-4">

src/electionguard_gui/web/components/admin/upload-ballots-component.js

@@ -14,6 +14,7 @@ export default {
       ballotsProcessed: null,
       ballotsTotal: null,
       success: false,
+      duplicateCount: 0,
     };
   },
   methods: {
@@ -27,7 +28,7 @@ export default {
           const ballotFiles = document.getElementById("ballotsFolder").files;
           this.ballotsTotal = ballotFiles.length;
 
-          const uploadId = await this.uploadDeviceFile(this.ballotsTotal);
+          const uploadId = await this.uploadDeviceFile();
           await this.uploadBallotFiles(uploadId, ballotFiles);
           this.success = true;
         }
@@ -39,15 +40,14 @@ export default {
         this.loading = false;
       }
     },
-    async uploadDeviceFile(ballotCount) {
+    async uploadDeviceFile() {
       const [deviceFile] = document.getElementById("deviceFile").files;
       const deviceContents = await deviceFile.text();
       console.log("Creating election", deviceFile.name);
       const result = await eel.create_ballot_upload(
         this.electionId,
         deviceFile.name,
-        deviceContents,
-        ballotCount
+        deviceContents
       )();
       if (!result.success) {
         throw new Error(result.message);
@@ -69,17 +69,44 @@ export default {
         if (!result.success) {
           throw new Error(result.message);
         }
+        if (result.result.is_duplicate) {
+          this.duplicateCount++;
+        }
         this.ballotsProcessed++;
       }
     },
     getElectionUrl: function () {
       return RouterService.getElectionUrl(this.electionId);
     },
+    uploadMore: function () {
+      this.success = false;
+      this.duplicateCount = 0;
+      this.election = null;
+      this.loading = false;
+      this.alert = null;
+      this.ballotsProcessed = null;
+      this.ballotsTotal = null;
+      this.success = false;
+      this.duplicateCount = 0;
+      this.$nextTick(() => {
+        this.resetFiles();
+      });
+    },
+    resetFiles: function () {
+      document.getElementById("deviceFile").value = null;
+      document.getElementById("ballotsFolder").value = null;
+    },
+  },
+  mounted() {
+    this.resetFiles();
   },
   template: /*html*/ `
     <div v-if="alert" class="alert alert-danger" role="alert">
       {{ alert }}
     </div>
+    <div v-if="duplicateCount" class="alert alert-warning" role="alert">
+      {{ duplicateCount }} ballots were skipped because their object_ids had already been uploaded for this election.
+    </div>
     <form id="mainForm" class="needs-validation" novalidate @submit.prevent="uploadBallots" v-if="!success">
       <div class="row g-3 align-items-center">
         <div class="col-12">
@@ -107,15 +134,17 @@ export default {
           <div class="invalid-feedback">Please provide a ballot folder.</div>
         </div>
         <div class="col-12 mt-4">
-          <button type="submit" :disabled="loading" class="btn btn-primary">Upload Ballots</button>
+          <button type="submit" :disabled="loading" class="btn btn-primary me-2">Upload Ballots</button>
+          <a :href="getElectionUrl()" class="btn btn-secondary me-2">Cancel</a>
           <spinner :visible="loading"></spinner>
           <p v-if="loading && ballotsProcessed">{{ ballotsProcessed }} of {{ ballotsTotal }} files processed.</p>
       </div>
     </form>
     <div v-if="success" class="text-center">
       <img src="/images/check.svg" width="200" height="200" class="mt-4 mb-2"></img>
-      <p>Successfully uploaded {{ballotsTotal}} ballots.</p>
-      <a :href="getElectionUrl()" class="btn btn-primary">Continue</a>
+      <p>Successfully uploaded {{ballotsTotal-duplicateCount}} ballots.</p>
+      <a :href="getElectionUrl()" class="btn btn-primary me-2">Done Uploading</a>
+      <button type="button" @click="uploadMore()" class="btn btn-secondary">Upload More Ballots</button>
     </div>
   `,
 };

src/electionguard_gui/web/components/admin/view-decryption-admin-component.js

@@ -47,7 +47,10 @@ export default {
     await this.get_decryption(false);
     eel.expose(this.refresh_decryption, "refresh_decryption");
     console.log("watching decryption");
-    eel.watch_decryption(this.decryptionId);
+    // only watch for changes if the decryption is in-progress
+    if (!this.decryption.completed_at_str) {
+      eel.watch_decryption(this.decryptionId);
+    }
   },
   unmounted() {
     console.log("stop watching decryption");
@@ -59,21 +62,45 @@ export default {
     </div>
     <div v-if="decryption">
       <div class="row mb-4">
-        <div class="col col-11">
+        <div class="col-11">
           <h1>{{decryption.decryption_name}}</h1>
         </div>
-        <div class="col col-xs-2 text-end" v-if="decryption.completed_at_str">
-          <a :href="getExportElectionRecordUrl()" class="btn btn-sm btn-primary" title="Download election record">
-            <i class="bi-download"></i>
-          </a>
+        <div class="col-1 text-end" v-if="decryption.completed_at_str">
+          <div class="dropdown">
+            <button class="btn btn-primary dropdown-toggle" type="button" data-bs-toggle="dropdown" aria-expanded="false">
+              <i class="bi-gear-fill me-1"></i>
+            </button>
+            <ul class="dropdown-menu">
+              <li>
+                <a :href="getExportElectionRecordUrl()" class="dropdown-item">
+                  <i class="bi-download me-1"></i> Download election record
+                </a>
+              </li>
+              <li>
+                <a :href="getViewTallyUrl()" class="dropdown-item" v-if="decryption.completed_at_str">
+                  <i class="bi-card-text me-1"></i> View Tally
+                </a>
+              </li>
+            </ul>
+          </div>
         </div>
       </div>
       <div class="row">
         <div class="col col-12 col-md-6 col-lg-5">
-          <div class="col-12">
+          <div class="col-md-8">
             <dt>Election</dt>
             <dd><a :href="getElectionUrl(decryption.election_id)">{{decryption.election_name}}</a></dd>
           </div>
+          <div class="row">
+            <div class="col-md-6">
+              <dt>Ballot Uploads</dt>
+              <dd>{{decryption.ballot_upload_count}}</dd>
+            </div>
+            <div class="col-md-6">
+              <dt>Total Ballots</dt>
+              <dd>{{decryption.ballot_count}}</dd>
+            </div>
+          </div>
           <dl class="col-12">
             <dt>Created</dt>
             <dd>by {{decryption.created_by}} on {{decryption.created_at}}</dd>