From f4a62b03dccc49667e8a7e91e1954f4ea26b4750 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wolfgang=20Hu=C3=9F?= <wolle.huss@pjannto.com>
Date: Fri, 8 Nov 2019 09:10:34 +0100
Subject: [PATCH] Clarify 'decide' resolver, rename to 'latest' property

---
 backend/src/schema/resolvers/moderation.js | 57 ++++++++++++----------
 backend/src/schema/resolvers/reports.js    |  2 +-
 2 files changed, 31 insertions(+), 28 deletions(-)

diff --git a/backend/src/schema/resolvers/moderation.js b/backend/src/schema/resolvers/moderation.js
index 1b6cc4027..a37d829f4 100644
--- a/backend/src/schema/resolvers/moderation.js
+++ b/backend/src/schema/resolvers/moderation.js
@@ -1,6 +1,23 @@
 import uuid from 'uuid/v4'
 import { undefinedToNullResolver } from './helpers/Resolver'
 
+const queryOpenDecisionWriteTransaction = (session, resourceId) => {
+  return session.writeTransaction(async txc => {
+    const queryOpenDecisionTransactionResponse = await txc.run(
+      `
+        MATCH (moderator:User)-[decision:DECIDED {closed: false}]->(resource {id: $resourceId})
+        WHERE resource:User OR resource:Comment OR resource:Post
+        RETURN decision, moderator {.id} AS decisionModerator
+      `,
+      { resourceId },
+    )
+    return queryOpenDecisionTransactionResponse.records.map(record => ({
+      decision: record.get('decision'),
+      decisionModerator: record.get('decisionModerator'),
+    }))
+  })
+}
+
 export default {
   Mutation: {
     decide: async (_object, params, context, _resolveInfo) => {
@@ -13,47 +30,32 @@ export default {
       const { user: moderator, driver } = context
 
       const session = driver.session()
-
-      const existingDecisionWriteTxResultPromise = session.writeTransaction(async txc => {
-        const decisionRelationshipTransactionResponse = await txc.run(
-          `
-            MATCH (moderator:User)-[decision:DECIDED {closed: false}]->(resource {id: $resourceId})
-            WHERE resource:User OR resource:Comment OR resource:Post
-            RETURN decision, moderator {.id} AS decisionModerator
-          `,
-          { resourceId },
-        )
-        return decisionRelationshipTransactionResponse.records.map(record => ({
-          decision: record.get('decision'),
-          decisionModerator: record.get('decisionModerator'),
-        }))
-      })
-
       try {
+        const queryOpenDecisionWriteTxResultPromise = queryOpenDecisionWriteTransaction(session, resourceId)
+        const [openDecisionTxResult] = await queryOpenDecisionWriteTxResultPromise
+
         let cypherHeader = ''
 
-        // is there an open decision?
-        const [existingDecisionTxResult] = await existingDecisionWriteTxResultPromise
-        if (!existingDecisionTxResult) {
+        if (!openDecisionTxResult) {
           // no open decision, then create one
           if (disable === undefined) disable = false // default for creation
           if (closed === undefined) closed = false // default for creation
           cypherHeader = `
               MATCH (resource {id: $resourceId})
               WHERE resource: User OR resource: Comment OR resource: Post
-              OPTIONAL MATCH (:User)-[lastDecision:DECIDED {last: true}]->(resource)
-              SET (CASE WHEN lastDecision IS NOT NULL THEN lastDecision END).last = false
+              OPTIONAL MATCH (:User)-[lastDecision:DECIDED {latest: true}]->(resource)
+              SET (CASE WHEN lastDecision IS NOT NULL THEN lastDecision END).latest = false
               WITH resource
               MATCH (moderator:User {id: $moderatorId})
               CREATE (resource)<-[decision:DECIDED]-(moderator)
-              SET decision.last = true
+              SET decision.latest = true
               `
         } else {
           // an open decision …
-          if (disable === undefined) disable = existingDecisionTxResult.decision.properties.disable // default set to existing
-          if (closed === undefined) closed = existingDecisionTxResult.decision.properties.closed // default set to existing
+          if (disable === undefined) disable = openDecisionTxResult.decision.properties.disable // default set to existing
+          if (closed === undefined) closed = openDecisionTxResult.decision.properties.closed // default set to existing
           // current moderator is not the same as old
-          if (moderator.id !== existingDecisionTxResult.decisionModerator.id) {
+          if (moderator.id !== openDecisionTxResult.decisionModerator.id) {
             // an open decision from different moderator, then change relation and properties
             cypherHeader = `
                 MATCH (moderator:User)-[oldDecision:DECIDED {closed: false}]->(resource {id: $resourceId})
@@ -99,14 +101,15 @@ export default {
         // console.log('disable: ', disable)
 
         const newDecisionWriteTxResultPromise = session.writeTransaction(async txc => {
-          const decisionRelationshipTransactionResponse = await txc.run(cypher, {
+          const mutateDecisionTransactionResponse = await txc.run(
+            cypher, {
             resourceId,
             moderatorId: moderator.id,
             disable,
             closed,
             decisionUUID,
           })
-          return decisionRelationshipTransactionResponse.records.map(record => ({
+          return mutateDecisionTransactionResponse.records.map(record => ({
             decision: record.get('decision'),
             resource: record.get('resource'),
             moderator: record.get('moderator'),
diff --git a/backend/src/schema/resolvers/reports.js b/backend/src/schema/resolvers/reports.js
index 8e7533a02..4e77ee5ec 100644
--- a/backend/src/schema/resolvers/reports.js
+++ b/backend/src/schema/resolvers/reports.js
@@ -81,7 +81,7 @@ export default {
           MATCH (submitter:User)-[report:REPORTED]->(resource)
           WHERE resource:User OR resource:Comment OR resource:Post
           OPTIONAL MATCH (:User)-[decision:DECIDED {uuid: report.decisionUuid}]->(resource)
-          OPTIONAL MATCH (:User)-[decisionPending:DECIDED {last: true}]->(resource)
+          OPTIONAL MATCH (:User)-[decisionPending:DECIDED {latest: true}]->(resource)
           RETURN report, submitter, resource, labels(resource)[0] as type, decision, decisionPending
           ${orderByClause}
         `