From 6950068a122d257c07504e99883300d7e1449ac3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 12:56:28 +0200
Subject: [PATCH 01/26] Sketch test for #1054

---
 .../resolvers/users/blockedUsers.spec.js      | 44 +++++++++++++++++++
 backend/src/schema/types/type/User.gql        | 11 +++++
 2 files changed, 55 insertions(+)
 create mode 100644 backend/src/schema/resolvers/users/blockedUsers.spec.js

diff --git a/backend/src/schema/resolvers/users/blockedUsers.spec.js b/backend/src/schema/resolvers/users/blockedUsers.spec.js
new file mode 100644
index 000000000..4a42f1c5c
--- /dev/null
+++ b/backend/src/schema/resolvers/users/blockedUsers.spec.js
@@ -0,0 +1,44 @@
+import { createTestClient } from 'apollo-server-testing'
+import createServer from '../../../server'
+import { gql } from '../../../jest/helpers'
+
+describe('blockedUsers', () => {
+  it.todo('throws permission error')
+
+  describe('authenticated', () => {
+  it.todo('returns a list of blocked users')
+  })
+})
+
+describe('block', () => {
+  it.todo('throws permission error')
+
+  describe('authenticated', () => {
+    it.todo('throws argument error')
+
+    describe('given a to-be-blocked user', () => {
+      it.todo('blocks a user')
+
+      describe('blocked user writes a post', () => {
+        it.todo('disappears in the newsfeed of the current user')
+      })
+
+      describe('current user writes a post', () => {
+        it.todo('disappears in the newsfeed of the blocked user')
+      })
+    })
+  })
+})
+
+describe('unblock', () => {
+  it.todo('throws permission error')
+  describe('authenticated', () => {
+    it.todo('throws argument error')
+    describe('given a blocked user', () => {
+      it.todo('unblocks a user')
+      describe('unblocking twice', () => {
+        it.todo('has no effect')
+      })
+    })
+  })
+})
diff --git a/backend/src/schema/types/type/User.gql b/backend/src/schema/types/type/User.gql
index 2534463d1..b58b64ac3 100644
--- a/backend/src/schema/types/type/User.gql
+++ b/backend/src/schema/types/type/User.gql
@@ -42,6 +42,12 @@ type User {
       RETURN COUNT(u) >= 1
     """
   )
+  isBlocked: Boolean! @cypher(
+    statement: """
+      MATCH (this)-[:BLOCKED]->(u:User {id: $cypherParams.currentUserId})
+      RETURN COUNT(u) >= 1
+    """
+  )
 
   #contributions: [WrittenPost]!
   #contributions2(first: Int = 10, offset: Int = 0): [WrittenPost2]!
@@ -164,4 +170,9 @@ type Mutation {
   ): User
 
   DeleteUser(id: ID!, resource: [Deletable]): User
+
+
+  block(id: ID!): User
+  unblock(id: ID!): User
+  blockedUsers: [User]
 }

From f8b37b5c1e74b0a68b9d6a363c1888d8c33b5863 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 14:02:11 +0200
Subject: [PATCH 02/26] Remove obsolete relationship 'BLACKLISTED'

---
 backend/src/schema/resolvers/users.js  |  1 -
 backend/src/schema/types/type/User.gql |  2 --
 backend/src/seed/seed-db.js            | 12 ------------
 3 files changed, 15 deletions(-)

diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index 77e4ae2aa..393ae8281 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -91,7 +91,6 @@ export default {
         followedBy: '<-[:FOLLOWS]-(related:User)',
         following: '-[:FOLLOWS]->(related:User)',
         friends: '-[:FRIENDS]-(related:User)',
-        blacklisted: '-[:BLACKLISTED]->(related:User)',
         socialMedia: '-[:OWNED_BY]->(related:SocialMedia',
         contributions: '-[:WROTE]->(related:Post)',
         comments: '-[:WROTE]->(related:Comment)',
diff --git a/backend/src/schema/types/type/User.gql b/backend/src/schema/types/type/User.gql
index b58b64ac3..74be4b5a6 100644
--- a/backend/src/schema/types/type/User.gql
+++ b/backend/src/schema/types/type/User.gql
@@ -73,8 +73,6 @@ type User {
   organizationsCreated: [Organization] @relation(name: "CREATED_ORGA", direction: "OUT")
   organizationsOwned: [Organization] @relation(name: "OWNING_ORGA", direction: "OUT")
 
-  blacklisted: [User]! @relation(name: "BLACKLISTED", direction: "OUT")
-
   categories: [Category]! @relation(name: "CATEGORIZED", direction: "OUT")
 
   badges: [Badge]! @relation(name: "REWARDED", direction: "IN")
diff --git a/backend/src/seed/seed-db.js b/backend/src/seed/seed-db.js
index c3a05248d..17380a4cc 100644
--- a/backend/src/seed/seed-db.js
+++ b/backend/src/seed/seed-db.js
@@ -135,18 +135,6 @@ import Factory from './factories'
         from: 'u2',
         to: 'u3',
       }),
-      f.relate('User', 'Blacklisted', {
-        from: 'u7',
-        to: 'u4',
-      }),
-      f.relate('User', 'Blacklisted', {
-        from: 'u7',
-        to: 'u5',
-      }),
-      f.relate('User', 'Blacklisted', {
-        from: 'u7',
-        to: 'u6',
-      }),
     ])
 
     await Promise.all([

From b63f6b0ba18a71a6bb8b5234a24b7557ccf23259 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 14:10:05 +0200
Subject: [PATCH 03/26] Setup blocked relationships in seeds

---
 backend/src/models/User.js  |  7 +++++
 backend/src/seed/seed-db.js | 54 ++++++++++---------------------------
 2 files changed, 21 insertions(+), 40 deletions(-)

diff --git a/backend/src/models/User.js b/backend/src/models/User.js
index 2c1575423..5125c75ec 100644
--- a/backend/src/models/User.js
+++ b/backend/src/models/User.js
@@ -48,6 +48,13 @@ module.exports = {
     target: 'Badge',
     direction: 'in',
   },
+  blocked: {
+    type: 'relationship',
+    relationship: 'BLOCKED',
+    target: 'User',
+    direction: 'out',
+    eager: true
+  },
   invitedBy: { type: 'relationship', relationship: 'INVITED', target: 'User', direction: 'in' },
   createdAt: { type: 'string', isoDate: true, default: () => new Date().toISOString() },
   updatedAt: {
diff --git a/backend/src/seed/seed-db.js b/backend/src/seed/seed-db.js
index 17380a4cc..394ca5e88 100644
--- a/backend/src/seed/seed-db.js
+++ b/backend/src/seed/seed-db.js
@@ -120,48 +120,22 @@ import Factory from './factories'
       bobDerBaumeister.relateTo(turtle, 'rewarded'),
       jennyRostock.relateTo(bear, 'rewarded'),
       dagobert.relateTo(rabbit, 'rewarded'),
-    ])
 
-    await Promise.all([
-      f.relate('User', 'Friends', {
-        from: 'u1',
-        to: 'u2',
-      }),
-      f.relate('User', 'Friends', {
-        from: 'u1',
-        to: 'u3',
-      }),
-      f.relate('User', 'Friends', {
-        from: 'u2',
-        to: 'u3',
-      }),
-    ])
+      peterLustig.relateTo(bobDerBaumeister, 'friends'),
+      peterLustig.relateTo(jennyRostock, 'friends'),
+      bobDerBaumeister.relateTo(jennyRostock, 'friends'),
 
-    await Promise.all([
-      asAdmin.follow({
-        id: 'u3',
-        type: 'User',
-      }),
-      asModerator.follow({
-        id: 'u4',
-        type: 'User',
-      }),
-      asUser.follow({
-        id: 'u4',
-        type: 'User',
-      }),
-      asTick.follow({
-        id: 'u6',
-        type: 'User',
-      }),
-      asTrick.follow({
-        id: 'u4',
-        type: 'User',
-      }),
-      asTrack.follow({
-        id: 'u3',
-        type: 'User',
-      }),
+      peterLustig.relateTo(jennyRostock, 'following'),
+      peterLustig.relateTo(tick, 'following'),
+      bobDerBaumeister.relateTo(tick, 'following'),
+      jennyRostock.relateTo(tick, 'following'),
+      tick.relateTo(track, 'following'),
+      trick.relateTo(tick, 'following'),
+      track.relateTo(jennyRostock, 'following'),
+
+      dagobert.relateTo(tick, 'blocked'),
+      dagobert.relateTo(trick, 'blocked'),
+      dagobert.relateTo(track, 'blocked'),
     ])
 
     await Promise.all([

From 05aee24efd5daa8108b9c189153878920d23abd9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 15:12:13 +0200
Subject: [PATCH 04/26] Implement+test User.blockedUsers resolver

---
 .../src/middleware/permissionsMiddleware.js   |  1 +
 backend/src/models/User.js                    |  1 -
 backend/src/schema/resolvers/users.js         | 29 +++++++
 .../resolvers/users/blockedUsers.spec.js      | 78 ++++++++++++++++++-
 backend/src/schema/types/type/User.gql        |  3 +-
 5 files changed, 107 insertions(+), 5 deletions(-)

diff --git a/backend/src/middleware/permissionsMiddleware.js b/backend/src/middleware/permissionsMiddleware.js
index 78f833c23..93096acba 100644
--- a/backend/src/middleware/permissionsMiddleware.js
+++ b/backend/src/middleware/permissionsMiddleware.js
@@ -159,6 +159,7 @@ const permissions = shield(
       Badge: allow,
       PostsEmotionsCountByEmotion: allow,
       PostsEmotionsByCurrentUser: allow,
+      blockedUsers: isAuthenticated,
     },
     Mutation: {
       '*': deny,
diff --git a/backend/src/models/User.js b/backend/src/models/User.js
index 5125c75ec..c952c0be6 100644
--- a/backend/src/models/User.js
+++ b/backend/src/models/User.js
@@ -53,7 +53,6 @@ module.exports = {
     relationship: 'BLOCKED',
     target: 'User',
     direction: 'out',
-    eager: true
   },
   invitedBy: { type: 'relationship', relationship: 'INVITED', target: 'User', direction: 'in' },
   createdAt: { type: 'string', isoDate: true, default: () => new Date().toISOString() },
diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index 393ae8281..b06f2d098 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -18,6 +18,23 @@ export default {
       }
       return neo4jgraphql(object, args, context, resolveInfo, false)
     },
+    blockedUsers: async (object, args, context, resolveInfo) => {
+      try {
+        const userModel = instance.model('User')
+        let blockedUsers = instance
+          .query()
+          .match('user', userModel)
+          .where('user.id', context.user.id)
+          .relationship(userModel.relationships().get('blocked'))
+          .to('blocked', userModel)
+          .return('blocked')
+        blockedUsers = await blockedUsers.execute()
+        blockedUsers = blockedUsers.records.map(r => r.get('blocked').properties)
+        return blockedUsers
+      } catch (e) {
+        throw new UserInputError(e.message)
+      }
+    },
   },
   Mutation: {
     UpdateUser: async (object, args, context, resolveInfo) => {
@@ -63,6 +80,18 @@ export default {
       const [{ email }] = result.records.map(r => r.get('e').properties)
       return email
     },
+    isBlocked: async (parent, params, context, resolveInfo) => {
+      if (typeof parent.isBlocked !== 'undefined') return parent.isBlocked
+      const result = await instance.cypher(
+        `
+      MATCH (u:User { id: $currentUser.id })-[:BLOCKED]->(b:User {id: $parent.id})
+      RETURN COUNT(u) >= 1 as isBlocked
+      `,
+        { parent, currentUser: context.user },
+      )
+      const [record] = result.records
+      return record.get('isBlocked')
+    },
     ...Resolver('User', {
       undefinedToNull: [
         'actorId',
diff --git a/backend/src/schema/resolvers/users/blockedUsers.spec.js b/backend/src/schema/resolvers/users/blockedUsers.spec.js
index 4a42f1c5c..c77ed76d3 100644
--- a/backend/src/schema/resolvers/users/blockedUsers.spec.js
+++ b/backend/src/schema/resolvers/users/blockedUsers.spec.js
@@ -1,12 +1,83 @@
 import { createTestClient } from 'apollo-server-testing'
 import createServer from '../../../server'
+import Factory from '../../../seed/factories'
 import { gql } from '../../../jest/helpers'
+import { neode, getDriver } from '../../../bootstrap/neo4j'
+
+const driver = getDriver()
+const factory = Factory()
+const instance = neode()
+
+let currentUser
+let blockedUser
+let server
+
+beforeEach(() => {
+  ;({ server } = createServer({
+    context: () => {
+      return {
+        user: currentUser,
+        driver,
+      }
+    },
+  }))
+})
+
+afterEach(async () => {
+  await factory.cleanDatabase()
+})
 
 describe('blockedUsers', () => {
-  it.todo('throws permission error')
+  let blockedUserQuery
+  beforeEach(() => {
+    blockedUserQuery = gql`
+      query {
+        blockedUsers {
+          id
+          name
+          isBlocked
+        }
+      }
+    `
+  })
 
-  describe('authenticated', () => {
-  it.todo('returns a list of blocked users')
+  it('throws permission error', async () => {
+    const { query } = createTestClient(server)
+    const result = await query({ query: blockedUserQuery })
+    expect(result.errors[0]).toHaveProperty('message', 'Not Authorised!')
+  })
+
+  describe('authenticated and given a blocked user', () => {
+    beforeEach(async () => {
+      currentUser = await instance.create('User', {
+        name: 'Current User',
+        id: 'u1',
+      })
+      blockedUser = await instance.create('User', {
+        name: 'Blocked User',
+        id: 'u2',
+      })
+      await currentUser.relateTo(blockedUser, 'blocked')
+      currentUser = await currentUser.toJson()
+      blockedUser = await blockedUser.toJson()
+    })
+
+    it('returns a list of blocked users', async () => {
+      const { query } = createTestClient(server)
+      await expect(query({ query: blockedUserQuery })).resolves.toEqual(
+        expect.objectContaining({
+          data: {
+            blockedUsers: [
+              {
+                name: 'Blocked User',
+                id: 'u2',
+                isBlocked: true,
+              },
+            ],
+          },
+        }),
+      )
+    })
   })
 })
 
@@ -18,6 +89,7 @@ describe('block', () => {
 
     describe('given a to-be-blocked user', () => {
       it.todo('blocks a user')
+      it.todo('removes any `FOLLOW` relationship')
 
       describe('blocked user writes a post', () => {
         it.todo('disappears in the newsfeed of the current user')
diff --git a/backend/src/schema/types/type/User.gql b/backend/src/schema/types/type/User.gql
index 74be4b5a6..c0b8220f5 100644
--- a/backend/src/schema/types/type/User.gql
+++ b/backend/src/schema/types/type/User.gql
@@ -152,6 +152,8 @@ type Query {
     orderBy: [_UserOrdering]
     filter: _UserFilter
   ): [User]
+
+  blockedUsers: [User]
 }
 
 type Mutation {
@@ -172,5 +174,4 @@ type Mutation {
 
   block(id: ID!): User
   unblock(id: ID!): User
-  blockedUsers: [User]
 }

From f5a59568ab7414ab9950a556ee4d4a462afd2e76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 16:59:28 +0200
Subject: [PATCH 05/26] Implement block except for the unfollow feature

---
 .../src/middleware/permissionsMiddleware.js   |  3 +-
 backend/src/schema/resolvers/users.js         | 29 ++++---
 .../resolvers/users/blockedUsers.spec.js      | 78 +++++++++++++++++--
 3 files changed, 94 insertions(+), 16 deletions(-)

diff --git a/backend/src/middleware/permissionsMiddleware.js b/backend/src/middleware/permissionsMiddleware.js
index 93096acba..bd5046331 100644
--- a/backend/src/middleware/permissionsMiddleware.js
+++ b/backend/src/middleware/permissionsMiddleware.js
@@ -10,7 +10,7 @@ const instance = neode()
 const isAuthenticated = rule({
   cache: 'contextual',
 })(async (_parent, _args, ctx, _info) => {
-  return ctx.user != null
+  return !!(ctx && ctx.user && ctx.user.id)
 })
 
 const isModerator = rule()(async (parent, args, { user }, info) => {
@@ -196,6 +196,7 @@ const permissions = shield(
       resetPassword: allow,
       AddPostEmotions: isAuthenticated,
       RemovePostEmotions: isAuthenticated,
+      block: isAuthenticated,
     },
     User: {
       email: isMyOwn,
diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index b06f2d098..394f74e8e 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -8,16 +8,6 @@ const instance = neode()
 
 export default {
   Query: {
-    User: async (object, args, context, resolveInfo) => {
-      const { email } = args
-      if (email) {
-        const e = await instance.first('EmailAddress', { email })
-        let user = e.get('belongsTo')
-        user = await user.toJson()
-        return [user.node]
-      }
-      return neo4jgraphql(object, args, context, resolveInfo, false)
-    },
     blockedUsers: async (object, args, context, resolveInfo) => {
       try {
         const userModel = instance.model('User')
@@ -35,8 +25,27 @@ export default {
         throw new UserInputError(e.message)
       }
     },
+    User: async (object, args, context, resolveInfo) => {
+      const { email } = args
+      if (email) {
+        const e = await instance.first('EmailAddress', { email })
+        let user = e.get('belongsTo')
+        user = await user.toJson()
+        return [user.node]
+      }
+      return neo4jgraphql(object, args, context, resolveInfo, false)
+    },
   },
   Mutation: {
+    block: async (object, args, context, resolveInfo) => {
+      if(context.user.id === args.id) return null
+      const [user, blockedUser] = await Promise.all([
+        instance.find('User', context.user.id),
+        instance.find('User', args.id)
+      ])
+      await user.relateTo(blockedUser, 'blocked')
+      return blockedUser.toJson()
+    },
     UpdateUser: async (object, args, context, resolveInfo) => {
       args = await fileUpload(args, { file: 'avatarUpload', url: 'avatar' })
       try {
diff --git a/backend/src/schema/resolvers/users/blockedUsers.spec.js b/backend/src/schema/resolvers/users/blockedUsers.spec.js
index c77ed76d3..826ea649d 100644
--- a/backend/src/schema/resolvers/users/blockedUsers.spec.js
+++ b/backend/src/schema/resolvers/users/blockedUsers.spec.js
@@ -13,11 +13,15 @@ let blockedUser
 let server
 
 beforeEach(() => {
+  currentUser = undefined
   ;({ server } = createServer({
     context: () => {
       return {
         user: currentUser,
         driver,
+        cypherParams: {
+          currentUserId: currentUser ? currentUser.id : null,
+        },
       }
     },
   }))
@@ -59,7 +63,6 @@ describe('blockedUsers', () => {
       })
       await currentUser.relateTo(blockedUser, 'blocked')
       currentUser = await currentUser.toJson()
-      blockedUser = await blockedUser.toJson()
     })
 
     it('returns a list of blocked users', async () => {
@@ -82,14 +85,79 @@ describe('blockedUsers', () => {
 })
 
 describe('block', () => {
-  it.todo('throws permission error')
+  let blockAction
+
+  beforeEach(() => {
+    currentUser = undefined
+    blockAction = (variables) => {
+      const { mutate } = createTestClient(server)
+      const blockMutation = gql`mutation($id: ID!) {
+        block(id: $id) {
+          id
+          name
+          isBlocked
+        }
+      }`
+      return mutate({ mutation: blockMutation, variables })
+    }
+  })
+
+  it('throws permission error', async () => {
+    const result = await blockAction({ id: 'u2' })
+    expect(result.errors[0]).toHaveProperty('message', 'Not Authorised!')
+  })
 
   describe('authenticated', () => {
-    it.todo('throws argument error')
+    beforeEach(async () => {
+      currentUser = await instance.create('User', {
+        name: 'Current User',
+        id: 'u1',
+      })
+      currentUser = await currentUser.toJson()
+    })
+
+    describe('block yourself', () => {
+      it('returns null', async () => {
+        await expect(blockAction({ id: 'u1' }))
+          .resolves.toEqual(expect.objectContaining({ data: { block: null } }))
+      })
+    })
+
+    describe('block not existing user', () => {
+      it('returns null', async () => {
+        await expect(blockAction({ id: 'u2' }))
+          .resolves.toEqual(expect.objectContaining({ data: { block: null } }))
+      })
+    })
 
     describe('given a to-be-blocked user', () => {
-      it.todo('blocks a user')
-      it.todo('removes any `FOLLOW` relationship')
+      beforeEach(async () => {
+        blockedUser = await instance.create('User', {
+          name: 'Blocked User',
+          id: 'u2',
+        })
+      })
+
+      it('blocks a user', async () => {
+        await expect(blockAction({ id: 'u2' }))
+          .resolves.toEqual(expect.objectContaining({
+            data: { block: { id: 'u2', name: 'Blocked User', isBlocked: true} }
+          }))
+      })
+
+      it('unfollows the user', async () => {
+        const user = await instance.find('User', currentUser.id)
+        await user.relateTo(blockedUser, 'following')
+        const queryUser = gql`query { User(id: "u2") { id isBlocked followedByCurrentUser } }`
+        const { query } = createTestClient(server)
+        await expect(query({ query: queryUser })).resolves.toEqual(expect.objectContaining({
+          data: { User: [{id: "u2", isBlocked: false, followedByCurrentUser: true }] }
+        }))
+        await blockAction({id: 'u2'})
+        await expect(query({ query: queryUser })).resolves.toEqual(expect.objectContaining({
+          data: { User: [{id: "u2", isBlocked: true, followedByCurrentUser: false }] }
+        }))
+      })
 
       describe('blocked user writes a post', () => {
         it.todo('disappears in the newsfeed of the current user')

From 700bdcb8f1608bb10af0ca24e20230284ab4f956 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 17:21:52 +0200
Subject: [PATCH 06/26] Implement+test unblock mutation

---
 .../src/middleware/permissionsMiddleware.js   |   1 +
 backend/src/schema/resolvers/users.js         |  17 +-
 .../resolvers/users/blockedUsers.spec.js      | 163 ++++++++++++++----
 3 files changed, 150 insertions(+), 31 deletions(-)

diff --git a/backend/src/middleware/permissionsMiddleware.js b/backend/src/middleware/permissionsMiddleware.js
index bd5046331..0f6f9e1c5 100644
--- a/backend/src/middleware/permissionsMiddleware.js
+++ b/backend/src/middleware/permissionsMiddleware.js
@@ -197,6 +197,7 @@ const permissions = shield(
       AddPostEmotions: isAuthenticated,
       RemovePostEmotions: isAuthenticated,
       block: isAuthenticated,
+      unblock: isAuthenticated,
     },
     User: {
       email: isMyOwn,
diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index 394f74e8e..66adc8734 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -38,14 +38,27 @@ export default {
   },
   Mutation: {
     block: async (object, args, context, resolveInfo) => {
-      if(context.user.id === args.id) return null
+      if (context.user.id === args.id) return null
       const [user, blockedUser] = await Promise.all([
         instance.find('User', context.user.id),
-        instance.find('User', args.id)
+        instance.find('User', args.id),
       ])
       await user.relateTo(blockedUser, 'blocked')
       return blockedUser.toJson()
     },
+    unblock: async (object, args, context, resolveInfo) => {
+      const { user: currentUser } = context
+      if (currentUser.id === args.id) return null
+      await instance.cypher(
+        `
+      MATCH(u:User {id: $currentUser.id})-[r:BLOCKED]->(b:User {id: $args.id})
+      DELETE r
+      `,
+        { currentUser, args },
+      )
+      const blockedUser = await instance.find('User', args.id)
+      return blockedUser.toJson()
+    },
     UpdateUser: async (object, args, context, resolveInfo) => {
       args = await fileUpload(args, { file: 'avatarUpload', url: 'avatar' })
       try {
diff --git a/backend/src/schema/resolvers/users/blockedUsers.spec.js b/backend/src/schema/resolvers/users/blockedUsers.spec.js
index 826ea649d..75fa791c0 100644
--- a/backend/src/schema/resolvers/users/blockedUsers.spec.js
+++ b/backend/src/schema/resolvers/users/blockedUsers.spec.js
@@ -89,15 +89,17 @@ describe('block', () => {
 
   beforeEach(() => {
     currentUser = undefined
-    blockAction = (variables) => {
+    blockAction = variables => {
       const { mutate } = createTestClient(server)
-      const blockMutation = gql`mutation($id: ID!) {
-        block(id: $id) {
-          id
-          name
-          isBlocked
+      const blockMutation = gql`
+        mutation($id: ID!) {
+          block(id: $id) {
+            id
+            name
+            isBlocked
+          }
         }
-      }`
+      `
       return mutate({ mutation: blockMutation, variables })
     }
   })
@@ -118,15 +120,17 @@ describe('block', () => {
 
     describe('block yourself', () => {
       it('returns null', async () => {
-        await expect(blockAction({ id: 'u1' }))
-          .resolves.toEqual(expect.objectContaining({ data: { block: null } }))
+        await expect(blockAction({ id: 'u1' })).resolves.toEqual(
+          expect.objectContaining({ data: { block: null } }),
+        )
       })
     })
 
     describe('block not existing user', () => {
       it('returns null', async () => {
-        await expect(blockAction({ id: 'u2' }))
-          .resolves.toEqual(expect.objectContaining({ data: { block: null } }))
+        await expect(blockAction({ id: 'u2' })).resolves.toEqual(
+          expect.objectContaining({ data: { block: null } }),
+        )
       })
     })
 
@@ -139,24 +143,37 @@ describe('block', () => {
       })
 
       it('blocks a user', async () => {
-        await expect(blockAction({ id: 'u2' }))
-          .resolves.toEqual(expect.objectContaining({
-            data: { block: { id: 'u2', name: 'Blocked User', isBlocked: true} }
-          }))
+        await expect(blockAction({ id: 'u2' })).resolves.toEqual(
+          expect.objectContaining({
+            data: { block: { id: 'u2', name: 'Blocked User', isBlocked: true } },
+          }),
+        )
       })
 
       it('unfollows the user', async () => {
         const user = await instance.find('User', currentUser.id)
         await user.relateTo(blockedUser, 'following')
-        const queryUser = gql`query { User(id: "u2") { id isBlocked followedByCurrentUser } }`
+        const queryUser = gql`
+          query {
+            User(id: "u2") {
+              id
+              isBlocked
+              followedByCurrentUser
+            }
+          }
+        `
         const { query } = createTestClient(server)
-        await expect(query({ query: queryUser })).resolves.toEqual(expect.objectContaining({
-          data: { User: [{id: "u2", isBlocked: false, followedByCurrentUser: true }] }
-        }))
-        await blockAction({id: 'u2'})
-        await expect(query({ query: queryUser })).resolves.toEqual(expect.objectContaining({
-          data: { User: [{id: "u2", isBlocked: true, followedByCurrentUser: false }] }
-        }))
+        await expect(query({ query: queryUser })).resolves.toEqual(
+          expect.objectContaining({
+            data: { User: [{ id: 'u2', isBlocked: false, followedByCurrentUser: true }] },
+          }),
+        )
+        await blockAction({ id: 'u2' })
+        await expect(query({ query: queryUser })).resolves.toEqual(
+          expect.objectContaining({
+            data: { User: [{ id: 'u2', isBlocked: true, followedByCurrentUser: false }] },
+          }),
+        )
       })
 
       describe('blocked user writes a post', () => {
@@ -171,13 +188,101 @@ describe('block', () => {
 })
 
 describe('unblock', () => {
-  it.todo('throws permission error')
+  let unblockAction
+
+  beforeEach(() => {
+    currentUser = undefined
+    unblockAction = variables => {
+      const { mutate } = createTestClient(server)
+      const unblockMutation = gql`
+        mutation($id: ID!) {
+          unblock(id: $id) {
+            id
+            name
+            isBlocked
+          }
+        }
+      `
+      return mutate({ mutation: unblockMutation, variables })
+    }
+  })
+
+  it('throws permission error', async () => {
+    const result = await unblockAction({ id: 'u2' })
+    expect(result.errors[0]).toHaveProperty('message', 'Not Authorised!')
+  })
+
   describe('authenticated', () => {
-    it.todo('throws argument error')
-    describe('given a blocked user', () => {
-      it.todo('unblocks a user')
-      describe('unblocking twice', () => {
-        it.todo('has no effect')
+    beforeEach(async () => {
+      currentUser = await instance.create('User', {
+        name: 'Current User',
+        id: 'u1',
+      })
+      currentUser = await currentUser.toJson()
+    })
+
+    describe('unblock yourself', () => {
+      it('returns null', async () => {
+        await expect(unblockAction({ id: 'u1' })).resolves.toEqual(
+          expect.objectContaining({ data: { unblock: null } }),
+        )
+      })
+    })
+
+    describe('unblock not-existing user', () => {
+      it('returns null', async () => {
+        await expect(unblockAction({ id: 'lksjdflksfdj' })).resolves.toEqual(
+          expect.objectContaining({ data: { unblock: null } }),
+        )
+      })
+    })
+
+    describe('given another user', () => {
+      let user, blockedUser
+
+      beforeEach(async () => {
+        ;[user, blockedUser] = await Promise.all([
+          instance.find('User', 'u1'),
+          instance.create('User', {
+            name: 'Blocked User',
+            id: 'u2',
+          }),
+        ])
+      })
+
+      describe('unblocking a not yet blocked user', () => {
+        it('does not hurt', async () => {
+          await expect(unblockAction({ id: 'u2' })).resolves.toEqual(
+            expect.objectContaining({
+              data: { unblock: { id: 'u2', name: 'Blocked User', isBlocked: false } },
+            }),
+          )
+        })
+      })
+
+      describe('given a blocked user', () => {
+        beforeEach(async () => {
+          await user.relateTo(blockedUser, 'blocked')
+        })
+
+        it('unblocks a user', async () => {
+          await expect(unblockAction({ id: 'u2' })).resolves.toEqual(
+            expect.objectContaining({
+              data: { unblock: { id: 'u2', name: 'Blocked User', isBlocked: false } },
+            }),
+          )
+        })
+
+        describe('unblocking twice', () => {
+          it('has no effect', async () => {
+            await unblockAction({ id: 'u2' })
+            await expect(unblockAction({ id: 'u2' })).resolves.toEqual(
+              expect.objectContaining({
+                data: { unblock: { id: 'u2', name: 'Blocked User', isBlocked: false } },
+              }),
+            )
+          })
+        })
       })
     })
   })

From 293054a05b87010bc7cb54c4afefc4f7543dc401 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 17:27:53 +0200
Subject: [PATCH 07/26] Implement block+unblock basic features

---
 backend/src/schema/resolvers/users.js  | 12 ++++++++++--
 backend/src/schema/types/type/User.gql |  2 +-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index 66adc8734..0824d62c0 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -38,9 +38,17 @@ export default {
   },
   Mutation: {
     block: async (object, args, context, resolveInfo) => {
-      if (context.user.id === args.id) return null
+      const { user: currentUser } = context
+      if (currentUser.id === args.id) return null
+      await instance.cypher(
+        `
+      MATCH(u:User {id: $currentUser.id})-[r:FOLLOWS]->(b:User {id: $args.id})
+      DELETE r
+      `,
+        { currentUser, args },
+      )
       const [user, blockedUser] = await Promise.all([
-        instance.find('User', context.user.id),
+        instance.find('User', currentUser.id),
         instance.find('User', args.id),
       ])
       await user.relateTo(blockedUser, 'blocked')
diff --git a/backend/src/schema/types/type/User.gql b/backend/src/schema/types/type/User.gql
index c0b8220f5..e3e8f8450 100644
--- a/backend/src/schema/types/type/User.gql
+++ b/backend/src/schema/types/type/User.gql
@@ -44,7 +44,7 @@ type User {
   )
   isBlocked: Boolean! @cypher(
     statement: """
-      MATCH (this)-[:BLOCKED]->(u:User {id: $cypherParams.currentUserId})
+      MATCH (this)<-[:BLOCKED]-(u:User {id: $cypherParams.currentUserId})
       RETURN COUNT(u) >= 1
     """
   )

From 824b2a5561d493df8957393420b3161def549bdf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Wed, 7 Aug 2019 19:07:20 +0200
Subject: [PATCH 08/26] Implement page for blocked users

---
 webapp/graphql/settings/BlockedUsers.js | 17 +++++
 webapp/locales/de.json                  | 14 ++++
 webapp/locales/en.json                  | 15 ++++
 webapp/pages/settings.vue               |  4 ++
 webapp/pages/settings/blocked-users.vue | 95 +++++++++++++++++++++++++
 5 files changed, 145 insertions(+)
 create mode 100644 webapp/graphql/settings/BlockedUsers.js
 create mode 100644 webapp/pages/settings/blocked-users.vue

diff --git a/webapp/graphql/settings/BlockedUsers.js b/webapp/graphql/settings/BlockedUsers.js
new file mode 100644
index 000000000..2cfd7bfe3
--- /dev/null
+++ b/webapp/graphql/settings/BlockedUsers.js
@@ -0,0 +1,17 @@
+import gql from 'graphql-tag'
+
+export default () => {
+  return gql(`
+    {
+      blockedUsers {
+        id
+        name
+        slug
+        avatar
+        about
+        disabled
+        deleted
+      }
+    }
+  `)
+}
diff --git a/webapp/locales/de.json b/webapp/locales/de.json
index 5a2b77131..2e89a72d0 100644
--- a/webapp/locales/de.json
+++ b/webapp/locales/de.json
@@ -189,6 +189,20 @@
       "submit": "Link hinzufügen",
       "successAdd": "Social-Media hinzugefügt. Profil aktualisiert!",
       "successDelete": "Social-Media gelöscht. Profil aktualisiert!"
+    },
+    "blocked-users": {
+      "name": "Blockierte Benutzer",
+      "explanation": {
+        "intro": "Wenn ein anderer Benutzer von dir blockiert wurde, dann passiert folgendes:",
+        "your-perspective": "In deiner Beitragsübersicht tauchen keine Beiträge der blockierten Person mehr auf.",
+        "their-perspective": "Umgekehrt das gleiche: Die blockierte Person sieht deine Beiträge auch nicht mehr in ihrer Übersicht.",
+        "closing": "Das sollte fürs Erste genügen, damit blockierte Benutzer dich nicht mehr länger belästigen können."
+      },
+      "columns": {
+        "name": "Name",
+        "slug": "Alias"
+      },
+      "empty": "Bislang hast du niemanden blockiert."
     }
   },
   "admin": {
diff --git a/webapp/locales/en.json b/webapp/locales/en.json
index fe0f1c99c..7f8441c71 100644
--- a/webapp/locales/en.json
+++ b/webapp/locales/en.json
@@ -189,6 +189,21 @@
       "submit": "Add link",
       "successAdd": "Added social media. Updated user profile!",
       "successDelete": "Deleted social media. Updated user profile!"
+    },
+    "blocked-users": {
+      "name": "Blocked users",
+      "explanation": {
+        "intro": "If another user has been blocked by you, this is what happens:",
+        "your-perspective": "The blocked person's posts will no longer appear in your news feed.",
+        "their-perspective": "Vice versa: The blocked person will also no longer see your posts in their news feed.",
+        "closing": "This should be sufficient for now so that blocked users can no longer bother you."
+
+      },
+      "columns": {
+        "name": "Name",
+        "slug": "Slug"
+      },
+      "empty": "So far, you did not block anybody."
     }
   },
   "admin": {
diff --git a/webapp/pages/settings.vue b/webapp/pages/settings.vue
index 1284aea7f..67493c333 100644
--- a/webapp/pages/settings.vue
+++ b/webapp/pages/settings.vue
@@ -31,6 +31,10 @@ export default {
           name: this.$t('settings.social-media.name'),
           path: `/settings/my-social-media`,
         },
+        {
+          name: this.$t('settings.blocked-users.name'),
+          path: `/settings/blocked-users`,
+        },
         {
           name: this.$t('settings.deleteUserAccount.name'),
           path: `/settings/delete-account`,
diff --git a/webapp/pages/settings/blocked-users.vue b/webapp/pages/settings/blocked-users.vue
new file mode 100644
index 000000000..b9bfcecd5
--- /dev/null
+++ b/webapp/pages/settings/blocked-users.vue
@@ -0,0 +1,95 @@
+<template>
+  <div>
+    <ds-space>
+      <ds-card :header="$t('settings.blocked-users.name')">
+        <ds-text>
+          {{ $t('settings.blocked-users.explanation.intro') }}
+        </ds-text>
+        <ds-list>
+          <ds-list-item>
+            {{ $t('settings.blocked-users.explanation.your-perspective') }}
+          </ds-list-item>
+          <ds-list-item>
+            {{ $t('settings.blocked-users.explanation.their-perspective') }}
+          </ds-list-item>
+        </ds-list>
+        <ds-text>
+          {{ $t('settings.blocked-users.explanation.closing') }}
+        </ds-text>
+      </ds-card>
+    </ds-space>
+    <ds-card v-if="blockedUsers && blockedUsers.length">
+      <ds-table :data="blockedUsers" :fields="fields" condensed>
+        <template slot="avatar" slot-scope="scope">
+          <nuxt-link
+            :to="{
+              name: 'profile-id-slug',
+              params: { id: scope.row.id, slug: scope.row.slug },
+            }"
+          >
+            <hc-avatar :user="scope" class="profile-avatar" size="small" />
+          </nuxt-link>
+        </template>
+        <template slot="name" slot-scope="scope">
+          <nuxt-link
+            :to="{
+              name: 'profile-id-slug',
+              params: { id: scope.row.id, slug: scope.row.slug },
+            }"
+          >
+            <b>{{ scope.row.name | truncate(20) }}</b>
+          </nuxt-link>
+        </template>
+        <template slot="slug" slot-scope="scope">
+          <nuxt-link
+            :to="{
+              name: 'profile-id-slug',
+              params: { id: scope.row.id, slug: scope.row.slug },
+            }"
+          >
+            <b>{{ scope.row.slug | truncate(20) }}</b>
+          </nuxt-link>
+        </template>
+      </ds-table>
+    </ds-card>
+    <ds-card v-else>
+      <ds-placeholder>
+        {{ $t('settings.blocked-users.empty') }}
+      </ds-placeholder>
+    </ds-card>
+  </div>
+</template>
+
+<script>
+import BlockedUsers from '~/graphql/settings/BlockedUsers'
+import HcAvatar from '~/components/Avatar/Avatar.vue'
+
+export default {
+  components: {
+    HcAvatar,
+  },
+  data() {
+    return {
+      blockedUsers: [],
+    }
+  },
+  computed: {
+    fields() {
+      return {
+        avatar: '',
+        name: this.$t('settings.blocked-users.columns.name'),
+        slug: this.$t('settings.blocked-users.columns.slug'),
+      }
+    },
+  },
+  apollo: {
+    blockedUsers: { query: BlockedUsers },
+  },
+}
+</script>
+
+<style lang="scss">
+.ds-table-col {
+  vertical-align: middle;
+}
+</style>

From 7f509b3201fa597f869cdff7517ee38ddbab088a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Thu, 8 Aug 2019 01:11:42 +0200
Subject: [PATCH 09/26] Implement block/unbock UI

---
 .../src/schema/resolvers/helpers/Resolver.js  | 23 +++++++++++++
 backend/src/schema/resolvers/users.js         | 18 ++++------
 webapp/components/ContentMenu.vue             | 33 +++++++++++++++----
 webapp/graphql/UserProfile/User.js            |  1 +
 webapp/graphql/settings/BlockedUsers.js       | 24 +++++++++++++-
 webapp/locales/de.json                        |  4 ++-
 webapp/locales/en.json                        |  4 ++-
 webapp/pages/profile/_id/_slug.vue            | 29 ++++++++++++----
 webapp/pages/settings/blocked-users.vue       |  2 +-
 9 files changed, 109 insertions(+), 29 deletions(-)

diff --git a/backend/src/schema/resolvers/helpers/Resolver.js b/backend/src/schema/resolvers/helpers/Resolver.js
index 655cf08a0..fd41205a3 100644
--- a/backend/src/schema/resolvers/helpers/Resolver.js
+++ b/backend/src/schema/resolvers/helpers/Resolver.js
@@ -15,10 +15,12 @@ export default function Resolver(type, options = {}) {
   const {
     idAttribute = 'id',
     undefinedToNull = [],
+    boolean = {},
     count = {},
     hasOne = {},
     hasMany = {},
   } = options
+
   const _hasResolver = (resolvers, { key, connection }, { returnType }) => {
     return async (parent, params, context, resolveInfo) => {
       if (typeof parent[key] !== 'undefined') return parent[key]
@@ -31,6 +33,26 @@ export default function Resolver(type, options = {}) {
     }
   }
 
+  const booleanResolver = obj => {
+    const resolvers = {}
+    for (const [key, condition] of Object.entries(obj)) {
+      resolvers[key] = async (parent, params, { cypherParams }, resolveInfo) => {
+        if (typeof parent[key] !== 'undefined') return parent[key]
+        const result = await instance.cypher(
+          `
+        ${condition.replace('this', 'this {id: $parent.id}')} as ${key}`,
+          {
+            parent,
+            cypherParams,
+          },
+        )
+        const [record] = result.records
+        return record.get(key)
+      }
+    }
+    return resolvers
+  }
+
   const countResolver = obj => {
     const resolvers = {}
     for (const [key, connection] of Object.entries(obj)) {
@@ -67,6 +89,7 @@ export default function Resolver(type, options = {}) {
   }
   const result = {
     ...undefinedToNullResolver(undefinedToNull),
+    ...booleanResolver(boolean),
     ...countResolver(count),
     ...hasOneResolver(hasOne),
     ...hasManyResolver(hasMany),
diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index 0824d62c0..767cde24b 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -110,18 +110,6 @@ export default {
       const [{ email }] = result.records.map(r => r.get('e').properties)
       return email
     },
-    isBlocked: async (parent, params, context, resolveInfo) => {
-      if (typeof parent.isBlocked !== 'undefined') return parent.isBlocked
-      const result = await instance.cypher(
-        `
-      MATCH (u:User { id: $currentUser.id })-[:BLOCKED]->(b:User {id: $parent.id})
-      RETURN COUNT(u) >= 1 as isBlocked
-      `,
-        { parent, currentUser: context.user },
-      )
-      const [record] = result.records
-      return record.get('isBlocked')
-    },
     ...Resolver('User', {
       undefinedToNull: [
         'actorId',
@@ -132,6 +120,12 @@ export default {
         'locationName',
         'about',
       ],
+      boolean: {
+        followedByCurrentUser:
+          'MATCH (this)<-[:FOLLOWS]-(u:User {id: $cypherParams.currentUserId}) RETURN COUNT(u) >= 1',
+        isBlocked:
+          'MATCH (this)<-[:BLOCKED]-(u:User {id: $cypherParams.currentUserId}) RETURN COUNT(u) >= 1',
+      },
       count: {
         contributionsCount: '-[:WROTE]->(related:Post)',
         friendsCount: '<-[:FRIENDS]->(related:User)',
diff --git a/webapp/components/ContentMenu.vue b/webapp/components/ContentMenu.vue
index 0ac885597..3b82486fe 100644
--- a/webapp/components/ContentMenu.vue
+++ b/webapp/components/ContentMenu.vue
@@ -122,13 +122,34 @@ export default {
         }
       }
 
-      if (this.isOwner && this.resourceType === 'user') {
-        routes.push({
-          name: this.$t(`settings.name`),
-          path: '/settings',
-          icon: 'edit',
-        })
+      if (this.resourceType === 'user') {
+        if (this.isOwner) {
+          routes.push({
+            name: this.$t(`settings.name`),
+            path: '/settings',
+            icon: 'edit',
+          })
+        } else {
+          if (this.resource.isBlocked) {
+            routes.push({
+              name: this.$t(`settings.blocked-users.unblock`),
+              callback: () => {
+                this.$emit('unblock', this.resource)
+              },
+              icon: 'user-plus',
+            })
+          } else {
+            routes.push({
+              name: this.$t(`settings.blocked-users.block`),
+              callback: () => {
+                this.$emit('block', this.resource)
+              },
+              icon: 'user-times',
+            })
+          }
+        }
       }
+
       return routes
     },
     isModerator() {
diff --git a/webapp/graphql/UserProfile/User.js b/webapp/graphql/UserProfile/User.js
index 897b5b91d..9febce142 100644
--- a/webapp/graphql/UserProfile/User.js
+++ b/webapp/graphql/UserProfile/User.js
@@ -46,6 +46,7 @@ export default i18n => {
         }
         followedByCount
         followedByCurrentUser
+        isBlocked
         followedBy(first: 7)  {
           id
           slug
diff --git a/webapp/graphql/settings/BlockedUsers.js b/webapp/graphql/settings/BlockedUsers.js
index 2cfd7bfe3..e47355b18 100644
--- a/webapp/graphql/settings/BlockedUsers.js
+++ b/webapp/graphql/settings/BlockedUsers.js
@@ -1,6 +1,6 @@
 import gql from 'graphql-tag'
 
-export default () => {
+export const BlockedUsers = () => {
   return gql(`
     {
       blockedUsers {
@@ -15,3 +15,25 @@ export default () => {
     }
   `)
 }
+
+export const Block = () => {
+  return gql(`mutation($id:ID!) {
+    block(id: $id) {
+      id
+      name
+      isBlocked
+      followedByCurrentUser
+    }
+  }`)
+}
+
+export const Unblock = () => {
+  return gql(`mutation($id:ID!) {
+    unblock(id: $id) {
+      id
+      name
+      isBlocked
+      followedByCurrentUser
+    }
+  }`)
+}
diff --git a/webapp/locales/de.json b/webapp/locales/de.json
index 2e89a72d0..5a77a85eb 100644
--- a/webapp/locales/de.json
+++ b/webapp/locales/de.json
@@ -202,7 +202,9 @@
         "name": "Name",
         "slug": "Alias"
       },
-      "empty": "Bislang hast du niemanden blockiert."
+      "empty": "Bislang hast du niemanden blockiert.",
+      "block": "Nutzer blockieren",
+      "unblock": "Nutzer entblocken"
     }
   },
   "admin": {
diff --git a/webapp/locales/en.json b/webapp/locales/en.json
index 7f8441c71..85e21abff 100644
--- a/webapp/locales/en.json
+++ b/webapp/locales/en.json
@@ -203,7 +203,9 @@
         "name": "Name",
         "slug": "Slug"
       },
-      "empty": "So far, you did not block anybody."
+      "empty": "So far, you did not block anybody.",
+      "block": "Block user",
+      "unblock": "Unblock user"
     }
   },
   "admin": {
diff --git a/webapp/pages/profile/_id/_slug.vue b/webapp/pages/profile/_id/_slug.vue
index 8a04e873b..a807740d0 100644
--- a/webapp/pages/profile/_id/_slug.vue
+++ b/webapp/pages/profile/_id/_slug.vue
@@ -22,6 +22,8 @@
               :resource="user"
               :is-owner="myProfile"
               class="user-content-menu"
+              @block="block"
+              @unblock="unblock"
             />
           </no-ssr>
           <ds-space margin="small">
@@ -54,13 +56,18 @@
             </ds-flex-item>
           </ds-flex>
           <ds-space margin="small">
-            <hc-follow-button
-              v-if="!myProfile"
-              :follow-id="user.id"
-              :is-followed="user.followedByCurrentUser"
-              @optimistic="follow => (user.followedByCurrentUser = follow)"
-              @update="follow => fetchUser()"
-            />
+            <template v-if="!myProfile">
+              <hc-follow-button
+                v-if="!user.isBlocked"
+                :follow-id="user.id"
+                :is-followed="user.followedByCurrentUser"
+                @optimistic="follow => (user.followedByCurrentUser = follow)"
+                @update="follow => fetchUser()"
+              />
+              <ds-button v-else fullwidth @click="unblock(user)">
+                {{ $t('settings.blocked-users.unblock') }}
+              </ds-button>
+            </template>
           </ds-space>
           <template v-if="user.about">
             <hr />
@@ -242,6 +249,7 @@ import HcUpload from '~/components/Upload'
 import HcAvatar from '~/components/Avatar/Avatar.vue'
 import PostQuery from '~/graphql/UserProfile/Post.js'
 import UserQuery from '~/graphql/UserProfile/User.js'
+import { Block, Unblock } from '~/graphql/settings/BlockedUsers.js'
 
 const tabToFilterMapping = ({ tab, id }) => {
   return {
@@ -372,6 +380,13 @@ export default {
       }
       return this.uniq(this.Post.filter(post => !post.deleted))
     },
+    async block(user) {
+      await this.$apollo.mutate({ mutation: Block(), variables: { id: user.id } })
+      await this.fetchUser()
+    },
+    async unblock(user) {
+      await this.$apollo.mutate({ mutation: Unblock(), variables: { id: user.id } })
+    },
   },
   apollo: {
     Post: {
diff --git a/webapp/pages/settings/blocked-users.vue b/webapp/pages/settings/blocked-users.vue
index b9bfcecd5..a91b81ba1 100644
--- a/webapp/pages/settings/blocked-users.vue
+++ b/webapp/pages/settings/blocked-users.vue
@@ -61,7 +61,7 @@
 </template>
 
 <script>
-import BlockedUsers from '~/graphql/settings/BlockedUsers'
+import { BlockedUsers } from '~/graphql/settings/BlockedUsers'
 import HcAvatar from '~/components/Avatar/Avatar.vue'
 
 export default {

From 3c610caca4f7ed5d45a88d379500fe61a424314a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Thu, 8 Aug 2019 01:13:18 +0200
Subject: [PATCH 10/26] Fix styling and avatar url of blocked users

---
 webapp/pages/settings/blocked-users.vue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/webapp/pages/settings/blocked-users.vue b/webapp/pages/settings/blocked-users.vue
index a91b81ba1..8b288eb7e 100644
--- a/webapp/pages/settings/blocked-users.vue
+++ b/webapp/pages/settings/blocked-users.vue
@@ -27,7 +27,7 @@
               params: { id: scope.row.id, slug: scope.row.slug },
             }"
           >
-            <hc-avatar :user="scope" class="profile-avatar" size="small" />
+            <hc-avatar :user="scope.row" size="small" />
           </nuxt-link>
         </template>
         <template slot="name" slot-scope="scope">

From bc4bffdc528139f5d93cbbc841ac3060d4c86d74 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Thu, 8 Aug 2019 01:24:28 +0200
Subject: [PATCH 11/26] Add How-To for blocking a user

---
 webapp/locales/de.json                  |  1 +
 webapp/locales/en.json                  |  5 +++--
 webapp/pages/settings/blocked-users.vue | 13 ++++++++++---
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/webapp/locales/de.json b/webapp/locales/de.json
index 5a77a85eb..13fdfe824 100644
--- a/webapp/locales/de.json
+++ b/webapp/locales/de.json
@@ -203,6 +203,7 @@
         "slug": "Alias"
       },
       "empty": "Bislang hast du niemanden blockiert.",
+      "how-to": "Du kannst andere Benutzer auf deren Profilseite über das Inhaltsmenü blockieren.",
       "block": "Nutzer blockieren",
       "unblock": "Nutzer entblocken"
     }
diff --git a/webapp/locales/en.json b/webapp/locales/en.json
index 85e21abff..e6f8a8193 100644
--- a/webapp/locales/en.json
+++ b/webapp/locales/en.json
@@ -204,8 +204,9 @@
         "slug": "Slug"
       },
       "empty": "So far, you did not block anybody.",
-      "block": "Block user",
-      "unblock": "Unblock user"
+      "how-to": "You can block other users on their profile page via the content menu.",
+      "block": "Block User",
+      "unblock": "Unblock User"
     }
   },
   "admin": {
diff --git a/webapp/pages/settings/blocked-users.vue b/webapp/pages/settings/blocked-users.vue
index 8b288eb7e..2969328fe 100644
--- a/webapp/pages/settings/blocked-users.vue
+++ b/webapp/pages/settings/blocked-users.vue
@@ -53,9 +53,16 @@
       </ds-table>
     </ds-card>
     <ds-card v-else>
-      <ds-placeholder>
-        {{ $t('settings.blocked-users.empty') }}
-      </ds-placeholder>
+      <ds-space>
+        <ds-placeholder>
+          {{ $t('settings.blocked-users.empty') }}
+        </ds-placeholder>
+      </ds-space>
+      <ds-space>
+        <ds-text align="center">
+          {{ $t('settings.blocked-users.how-to') }}
+        </ds-text>
+      </ds-space>
     </ds-card>
   </div>
 </template>

From cc1f9328032c1dbd49d543473f681af3a6093eec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Fri, 9 Aug 2019 00:49:40 +0200
Subject: [PATCH 12/26] Refactor tests with `Post` model

---
 backend/src/models/User.js                    |  12 +-
 .../resolvers/users/blockedUsers.spec.js      | 108 ++++++++++++------
 webapp/locales/en.json                        |   2 +-
 3 files changed, 83 insertions(+), 39 deletions(-)

diff --git a/backend/src/models/User.js b/backend/src/models/User.js
index c952c0be6..3dfcef06a 100644
--- a/backend/src/models/User.js
+++ b/backend/src/models/User.js
@@ -48,12 +48,6 @@ module.exports = {
     target: 'Badge',
     direction: 'in',
   },
-  blocked: {
-    type: 'relationship',
-    relationship: 'BLOCKED',
-    target: 'User',
-    direction: 'out',
-  },
   invitedBy: { type: 'relationship', relationship: 'INVITED', target: 'User', direction: 'in' },
   createdAt: { type: 'string', isoDate: true, default: () => new Date().toISOString() },
   updatedAt: {
@@ -77,4 +71,10 @@ module.exports = {
     eager: true,
     cascade: true,
   },
+  blocked: {
+    type: 'relationship',
+    relationship: 'BLOCKED',
+    target: 'User',
+    direction: 'out',
+  },
 }
diff --git a/backend/src/schema/resolvers/users/blockedUsers.spec.js b/backend/src/schema/resolvers/users/blockedUsers.spec.js
index 75fa791c0..e20774b0a 100644
--- a/backend/src/schema/resolvers/users/blockedUsers.spec.js
+++ b/backend/src/schema/resolvers/users/blockedUsers.spec.js
@@ -10,17 +10,18 @@ const instance = neode()
 
 let currentUser
 let blockedUser
+let authenticatedUser
 let server
 
 beforeEach(() => {
-  currentUser = undefined
+  authenticatedUser = undefined
   ;({ server } = createServer({
     context: () => {
       return {
-        user: currentUser,
+        user: authenticatedUser,
         driver,
         cypherParams: {
-          currentUserId: currentUser ? currentUser.id : null,
+          currentUserId: authenticatedUser ? authenticatedUser.id : null,
         },
       }
     },
@@ -62,7 +63,7 @@ describe('blockedUsers', () => {
         id: 'u2',
       })
       await currentUser.relateTo(blockedUser, 'blocked')
-      currentUser = await currentUser.toJson()
+      authenticatedUser = await currentUser.toJson()
     })
 
     it('returns a list of blocked users', async () => {
@@ -115,7 +116,7 @@ describe('block', () => {
         name: 'Current User',
         id: 'u1',
       })
-      currentUser = await currentUser.toJson()
+      authenticatedUser = await currentUser.toJson()
     })
 
     describe('block yourself', () => {
@@ -151,17 +152,8 @@ describe('block', () => {
       })
 
       it('unfollows the user', async () => {
-        const user = await instance.find('User', currentUser.id)
-        await user.relateTo(blockedUser, 'following')
-        const queryUser = gql`
-          query {
-            User(id: "u2") {
-              id
-              isBlocked
-              followedByCurrentUser
-            }
-          }
-        `
+        await currentUser.relateTo(blockedUser, 'following')
+        const queryUser = gql` query { User(id: "u2") { id isBlocked followedByCurrentUser } }`
         const { query } = createTestClient(server)
         await expect(query({ query: queryUser })).resolves.toEqual(
           expect.objectContaining({
@@ -176,12 +168,69 @@ describe('block', () => {
         )
       })
 
-      describe('blocked user writes a post', () => {
-        it.todo('disappears in the newsfeed of the current user')
-      })
+      describe('given both the current user and the to-be-blocked user write a post', () => {
+        let postQuery
 
-      describe('current user writes a post', () => {
-        it.todo('disappears in the newsfeed of the blocked user')
+        beforeEach(async () => {
+          const post1 = await instance.create('Post', {
+            id: 'p12',
+            title: 'A post written by the current user',
+          })
+          const post2 = await instance.create('Post', {
+            id: 'p23',
+            title: 'A post written by the blocked user',
+          })
+          await Promise.all([
+            post1.relateTo(currentUser, 'author'),
+            post2.relateTo(blockedUser, 'author')
+          ])
+          postQuery = gql`query { Post(orderBy: createdAt_asc) { id title author { id name } } }`
+        })
+
+        const bothPostsAreInTheNewsfeed = async () => {
+            const { query } = createTestClient(server)
+            await expect(query({ query: postQuery })).resolves.toEqual(
+              expect.objectContaining({
+                data: {
+                  Post: [
+                    {
+                      id: 'p12',
+                      title: 'A post written by the current user',
+                      author: {
+                        name: 'Current User',
+                        id: 'u1',
+                      }
+                    },
+                    {
+                      id: 'p23',
+                      title: 'A post written by the blocked user',
+                      author: {
+                        name: 'Blocked User',
+                        id: 'u2',
+                      }
+                    },
+                  ],
+                },
+              }),
+            )
+          }
+
+        describe('from the perspective of the current user', () => {
+          it('both posts are in the newsfeed', bothPostsAreInTheNewsfeed)
+
+          describe('but if the current user blocks the other user', () => {
+            beforeEach(async () => { })
+
+            it.todo("the blocked user's post won't show up in the newsfeed of the current user")
+          })
+        })
+
+        describe('from the perspective of the blocked user', () => {
+          it('both posts are in the newsfeed', bothPostsAreInTheNewsfeed)
+          describe('but if the current user blocks the other user', () => {
+            it.todo("the current user's post won't show up in the newsfeed of the blocked user")
+          })
+        })
       })
     })
   })
@@ -218,7 +267,7 @@ describe('unblock', () => {
         name: 'Current User',
         id: 'u1',
       })
-      currentUser = await currentUser.toJson()
+      authenticatedUser = await currentUser.toJson()
     })
 
     describe('unblock yourself', () => {
@@ -238,16 +287,11 @@ describe('unblock', () => {
     })
 
     describe('given another user', () => {
-      let user, blockedUser
-
       beforeEach(async () => {
-        ;[user, blockedUser] = await Promise.all([
-          instance.find('User', 'u1'),
-          instance.create('User', {
-            name: 'Blocked User',
-            id: 'u2',
-          }),
-        ])
+        blockedUser = await instance.create('User', {
+          name: 'Blocked User',
+          id: 'u2',
+        })
       })
 
       describe('unblocking a not yet blocked user', () => {
@@ -262,7 +306,7 @@ describe('unblock', () => {
 
       describe('given a blocked user', () => {
         beforeEach(async () => {
-          await user.relateTo(blockedUser, 'blocked')
+          await currentUser.relateTo(blockedUser, 'blocked')
         })
 
         it('unblocks a user', async () => {
diff --git a/webapp/locales/en.json b/webapp/locales/en.json
index e6f8a8193..70dbae8ce 100644
--- a/webapp/locales/en.json
+++ b/webapp/locales/en.json
@@ -203,7 +203,7 @@
         "name": "Name",
         "slug": "Slug"
       },
-      "empty": "So far, you did not block anybody.",
+      "empty": "So far, you have not blocked anybody.",
       "how-to": "You can block other users on their profile page via the content menu.",
       "block": "Block User",
       "unblock": "Unblock User"

From 5fb60d1132d4ee5fc4e30efc11fae6dbcbeda3c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Fri, 9 Aug 2019 00:55:44 +0200
Subject: [PATCH 13/26] Implement+test blocking a user on backend

---
 backend/src/schema/resolvers/posts.js         |  84 +++++++-----
 backend/src/schema/resolvers/users.js         |  42 ++++--
 .../resolvers/users/blockedUsers.spec.js      | 120 +++++++++++++-----
 backend/src/server.js                         |   4 +-
 4 files changed, 173 insertions(+), 77 deletions(-)

diff --git a/backend/src/schema/resolvers/posts.js b/backend/src/schema/resolvers/posts.js
index 336f816f5..6cfd38575 100644
--- a/backend/src/schema/resolvers/posts.js
+++ b/backend/src/schema/resolvers/posts.js
@@ -1,7 +1,56 @@
 import uuid from 'uuid/v4'
+import { neo4jgraphql } from 'neo4j-graphql-js'
 import fileUpload from './fileUpload'
+import { getBlockedUsers, getBlockedByUsers } from './users.js'
 
 export default {
+  Query: {
+    Post: async (object, params, context, resolveInfo) => {
+      const blockedUsers = await getBlockedUsers(context)
+      const blockedByUsers = await getBlockedByUsers(context)
+      params.filter = {
+        author_not: { id_in: [
+          ...blockedByUsers.map(b => b.id),
+          ...blockedUsers.map(b => b.id),
+        ] }
+      }
+
+      return neo4jgraphql(object, params, context, resolveInfo, false)
+    },
+    PostsEmotionsCountByEmotion: async (object, params, context, resolveInfo) => {
+      const session = context.driver.session()
+      const { postId, data } = params
+      const transactionRes = await session.run(
+        `MATCH (post:Post {id: $postId})<-[emoted:EMOTED {emotion: $data.emotion}]-()
+        RETURN COUNT(DISTINCT emoted) as emotionsCount
+        `,
+        { postId, data },
+      )
+      session.close()
+
+      const [emotionsCount] = transactionRes.records.map(record => {
+        return record.get('emotionsCount').low
+      })
+
+      return emotionsCount
+    },
+    PostsEmotionsByCurrentUser: async (object, params, context, resolveInfo) => {
+      const session = context.driver.session()
+      const { postId } = params
+      const transactionRes = await session.run(
+        `MATCH (user:User {id: $userId})-[emoted:EMOTED]->(post:Post {id: $postId})
+        RETURN collect(emoted.emotion) as emotion`,
+        { userId: context.user.id, postId },
+      )
+
+      session.close()
+
+      const [emotions] = transactionRes.records.map(record => {
+        return record.get('emotion')
+      })
+      return emotions
+    },
+  },
   Mutation: {
     UpdatePost: async (object, params, context, resolveInfo) => {
       const { categoryIds } = params
@@ -112,39 +161,4 @@ export default {
       return emoted
     },
   },
-  Query: {
-    PostsEmotionsCountByEmotion: async (object, params, context, resolveInfo) => {
-      const session = context.driver.session()
-      const { postId, data } = params
-      const transactionRes = await session.run(
-        `MATCH (post:Post {id: $postId})<-[emoted:EMOTED {emotion: $data.emotion}]-() 
-        RETURN COUNT(DISTINCT emoted) as emotionsCount
-        `,
-        { postId, data },
-      )
-      session.close()
-
-      const [emotionsCount] = transactionRes.records.map(record => {
-        return record.get('emotionsCount').low
-      })
-
-      return emotionsCount
-    },
-    PostsEmotionsByCurrentUser: async (object, params, context, resolveInfo) => {
-      const session = context.driver.session()
-      const { postId } = params
-      const transactionRes = await session.run(
-        `MATCH (user:User {id: $userId})-[emoted:EMOTED]->(post:Post {id: $postId})
-        RETURN collect(emoted.emotion) as emotion`,
-        { userId: context.user.id, postId },
-      )
-
-      session.close()
-
-      const [emotions] = transactionRes.records.map(record => {
-        return record.get('emotion')
-      })
-      return emotions
-    },
-  },
 }
diff --git a/backend/src/schema/resolvers/users.js b/backend/src/schema/resolvers/users.js
index 767cde24b..74561c5fe 100644
--- a/backend/src/schema/resolvers/users.js
+++ b/backend/src/schema/resolvers/users.js
@@ -6,21 +6,41 @@ import Resolver from './helpers/Resolver'
 
 const instance = neode()
 
+export const getBlockedUsers = async context => {
+  const { neode } = context
+  const userModel = neode.model('User')
+  let blockedUsers = neode
+    .query()
+    .match('user', userModel)
+    .where('user.id', context.user.id)
+    .relationship(userModel.relationships().get('blocked'))
+    .to('blocked', userModel)
+    .return('blocked')
+  blockedUsers = await blockedUsers.execute()
+  blockedUsers = blockedUsers.records.map(r => r.get('blocked').properties)
+  return blockedUsers
+}
+
+export const getBlockedByUsers = async context => {
+  const { neode } = context
+  const userModel = neode.model('User')
+  let blockedByUsers = neode
+    .query()
+    .match('user', userModel)
+    .relationship(userModel.relationships().get('blocked'))
+    .to('blocked', userModel)
+    .where('blocked.id', context.user.id)
+    .return('user')
+  blockedByUsers = await blockedByUsers.execute()
+  blockedByUsers = blockedByUsers.records.map(r => r.get('user').properties)
+  return blockedByUsers
+}
+
 export default {
   Query: {
     blockedUsers: async (object, args, context, resolveInfo) => {
       try {
-        const userModel = instance.model('User')
-        let blockedUsers = instance
-          .query()
-          .match('user', userModel)
-          .where('user.id', context.user.id)
-          .relationship(userModel.relationships().get('blocked'))
-          .to('blocked', userModel)
-          .return('blocked')
-        blockedUsers = await blockedUsers.execute()
-        blockedUsers = blockedUsers.records.map(r => r.get('blocked').properties)
-        return blockedUsers
+        return getBlockedUsers(context)
       } catch (e) {
         throw new UserInputError(e.message)
       }
diff --git a/backend/src/schema/resolvers/users/blockedUsers.spec.js b/backend/src/schema/resolvers/users/blockedUsers.spec.js
index e20774b0a..887c34494 100644
--- a/backend/src/schema/resolvers/users/blockedUsers.spec.js
+++ b/backend/src/schema/resolvers/users/blockedUsers.spec.js
@@ -20,6 +20,7 @@ beforeEach(() => {
       return {
         user: authenticatedUser,
         driver,
+        neode: instance,
         cypherParams: {
           currentUserId: authenticatedUser ? authenticatedUser.id : null,
         },
@@ -153,7 +154,15 @@ describe('block', () => {
 
       it('unfollows the user', async () => {
         await currentUser.relateTo(blockedUser, 'following')
-        const queryUser = gql` query { User(id: "u2") { id isBlocked followedByCurrentUser } }`
+        const queryUser = gql`
+          query {
+            User(id: "u2") {
+              id
+              isBlocked
+              followedByCurrentUser
+            }
+          }
+        `
         const { query } = createTestClient(server)
         await expect(query({ query: queryUser })).resolves.toEqual(
           expect.objectContaining({
@@ -182,53 +191,104 @@ describe('block', () => {
           })
           await Promise.all([
             post1.relateTo(currentUser, 'author'),
-            post2.relateTo(blockedUser, 'author')
+            post2.relateTo(blockedUser, 'author'),
           ])
-          postQuery = gql`query { Post(orderBy: createdAt_asc) { id title author { id name } } }`
+          postQuery = gql`
+            query {
+              Post(orderBy: createdAt_asc) {
+                id
+                title
+                author {
+                  id
+                  name
+                }
+              }
+            }
+          `
         })
 
         const bothPostsAreInTheNewsfeed = async () => {
-            const { query } = createTestClient(server)
-            await expect(query({ query: postQuery })).resolves.toEqual(
-              expect.objectContaining({
-                data: {
-                  Post: [
-                    {
-                      id: 'p12',
-                      title: 'A post written by the current user',
-                      author: {
-                        name: 'Current User',
-                        id: 'u1',
-                      }
+          const { query } = createTestClient(server)
+          await expect(query({ query: postQuery })).resolves.toEqual(
+            expect.objectContaining({
+              data: {
+                Post: [
+                  {
+                    id: 'p12',
+                    title: 'A post written by the current user',
+                    author: {
+                      name: 'Current User',
+                      id: 'u1',
                     },
-                    {
-                      id: 'p23',
-                      title: 'A post written by the blocked user',
-                      author: {
-                        name: 'Blocked User',
-                        id: 'u2',
-                      }
+                  },
+                  {
+                    id: 'p23',
+                    title: 'A post written by the blocked user',
+                    author: {
+                      name: 'Blocked User',
+                      id: 'u2',
                     },
-                  ],
-                },
-              }),
-            )
-          }
+                  },
+                ],
+              },
+            }),
+          )
+        }
 
         describe('from the perspective of the current user', () => {
           it('both posts are in the newsfeed', bothPostsAreInTheNewsfeed)
 
           describe('but if the current user blocks the other user', () => {
-            beforeEach(async () => { })
+            beforeEach(async () => {
+              await currentUser.relateTo(blockedUser, 'blocked')
+            })
 
-            it.todo("the blocked user's post won't show up in the newsfeed of the current user")
+            it("the blocked user's post won't show up in the newsfeed of the current user", async () => {
+              const { query } = createTestClient(server)
+              await expect(query({ query: postQuery })).resolves.toEqual(
+                expect.objectContaining({
+                  data: {
+                    Post: [
+                      {
+                        id: 'p12',
+                        title: 'A post written by the current user',
+                        author: { name: 'Current User', id: 'u1' },
+                      },
+                    ],
+                  },
+                }),
+              )
+            })
           })
         })
 
         describe('from the perspective of the blocked user', () => {
+          beforeEach(async () => {
+            authenticatedUser = await blockedUser.toJson()
+          })
+
           it('both posts are in the newsfeed', bothPostsAreInTheNewsfeed)
           describe('but if the current user blocks the other user', () => {
-            it.todo("the current user's post won't show up in the newsfeed of the blocked user")
+            beforeEach(async () => {
+              await currentUser.relateTo(blockedUser, 'blocked')
+            })
+
+            it("the current user's post won't show up in the newsfeed of the blocked user", async () => {
+              const { query } = createTestClient(server)
+              await expect(query({ query: postQuery })).resolves.toEqual(
+                expect.objectContaining({
+                  data: {
+                    Post: [
+                      {
+                        id: 'p23',
+                        title: 'A post written by the blocked user',
+                        author: { name: 'Blocked User', id: 'u2' },
+                      },
+                    ],
+                  },
+                }),
+              )
+            })
           })
         })
       })
diff --git a/backend/src/server.js b/backend/src/server.js
index 5f13daeea..752cd96fb 100644
--- a/backend/src/server.js
+++ b/backend/src/server.js
@@ -3,7 +3,7 @@ import helmet from 'helmet'
 import { ApolloServer } from 'apollo-server-express'
 import CONFIG, { requiredConfigs } from './config'
 import middleware from './middleware'
-import { getDriver } from './bootstrap/neo4j'
+import { neode as getNeode, getDriver } from './bootstrap/neo4j'
 import decode from './jwt/decode'
 import schema from './schema'
 
@@ -16,6 +16,7 @@ Object.entries(requiredConfigs).map(entry => {
 })
 
 const driver = getDriver()
+const neode = getNeode()
 
 const createServer = options => {
   const defaults = {
@@ -23,6 +24,7 @@ const createServer = options => {
       const user = await decode(driver, req.headers.authorization)
       return {
         driver,
+        neode,
         user,
         req,
         cypherParams: {

From 8de0195cf838c33acf90089846548d7960f8b715 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Fri, 9 Aug 2019 01:43:13 +0200
Subject: [PATCH 14/26] Keep existing filter params + same for text search

---
 backend/src/schema/resolvers/posts.js | 35 ++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/backend/src/schema/resolvers/posts.js b/backend/src/schema/resolvers/posts.js
index 6cfd38575..884bd4659 100644
--- a/backend/src/schema/resolvers/posts.js
+++ b/backend/src/schema/resolvers/posts.js
@@ -2,19 +2,36 @@ import uuid from 'uuid/v4'
 import { neo4jgraphql } from 'neo4j-graphql-js'
 import fileUpload from './fileUpload'
 import { getBlockedUsers, getBlockedByUsers } from './users.js'
+import { mergeWith, isArray } from 'lodash'
+
+const filterForBlockedUsers = async (params, context) => {
+  const [blockedUsers, blockedByUsers] = await Promise.all([
+    getBlockedUsers(context),
+    getBlockedByUsers(context),
+  ])
+  const badIds = [...blockedByUsers.map(b => b.id), ...blockedUsers.map(b => b.id)]
+  params.filter = mergeWith(
+    params.filter,
+    {
+      author_not: { id_in: badIds },
+    },
+    (objValue, srcValue) => {
+      if (isArray(objValue)) {
+        return objValue.concat(srcValue)
+      }
+    },
+  )
+  return params
+}
 
 export default {
   Query: {
     Post: async (object, params, context, resolveInfo) => {
-      const blockedUsers = await getBlockedUsers(context)
-      const blockedByUsers = await getBlockedByUsers(context)
-      params.filter = {
-        author_not: { id_in: [
-          ...blockedByUsers.map(b => b.id),
-          ...blockedUsers.map(b => b.id),
-        ] }
-      }
-
+      params = await filterForBlockedUsers(params, context)
+      return neo4jgraphql(object, params, context, resolveInfo, false)
+    },
+    findPosts: async (object, params, context, resolveInfo) => {
+      params = await filterForBlockedUsers(params, context)
       return neo4jgraphql(object, params, context, resolveInfo, false)
     },
     PostsEmotionsCountByEmotion: async (object, params, context, resolveInfo) => {

From bedbb21def48d0fb7c5177f36bab40438d822b3d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Mon, 12 Aug 2019 11:47:18 +0200
Subject: [PATCH 15/26] Refactor notification spec

Wow this took me the entire day: If you run `createServer` multiple
times, more and more middlewares get added to the schema. That's why
the test would create 2^n notifications for n times you called
`createServer`. This is related to the following bug:

https://github.com/prisma/graphql-middleware/issues/63
---
 .../handleContentData.spec.js                 | 224 ++++++++----------
 .../notifications/extractMentionedUsers.js    |   6 +-
 .../extractMentionedUsers.spec.js             |   6 +
 backend/src/models/Notification.js            |  19 ++
 backend/src/models/User.js                    |   6 +
 backend/src/models/index.js                   |   1 +
 backend/src/schema/types/schema.gql           |   8 -
 .../src/schema/types/type/Notification.gql    |   7 +
 8 files changed, 147 insertions(+), 130 deletions(-)
 create mode 100644 backend/src/models/Notification.js
 create mode 100644 backend/src/schema/types/type/Notification.gql

diff --git a/backend/src/middleware/handleHtmlContent/handleContentData.spec.js b/backend/src/middleware/handleHtmlContent/handleContentData.spec.js
index 6fe5d3891..1effeb5d6 100644
--- a/backend/src/middleware/handleHtmlContent/handleContentData.spec.js
+++ b/backend/src/middleware/handleHtmlContent/handleContentData.spec.js
@@ -1,12 +1,36 @@
-import { GraphQLClient } from 'graphql-request'
-import { host, login, gql } from '../../jest/helpers'
+import { gql } from '../../jest/helpers'
 import Factory from '../../seed/factories'
+import { createTestClient } from 'apollo-server-testing'
+import { neode, getDriver } from '../../bootstrap/neo4j'
+import createServer from '../../server'
 
 const factory = Factory()
-let client
+const driver = getDriver()
+const instance = neode()
+let server
+let query
+let mutate
+let user
+let authenticatedUser
+
+beforeAll(() => {
+  const createServerResult = createServer({
+    context: () => {
+      return {
+        user: authenticatedUser,
+        neode: instance,
+        driver,
+      }
+    },
+  })
+  server = createServerResult.server
+  const createTestClientResult = createTestClient(server)
+  query = createTestClientResult.query
+  mutate = createTestClientResult.mutate
+})
 
 beforeEach(async () => {
-  await factory.create('User', {
+  user = await instance.create('User', {
     id: 'you',
     name: 'Al Capone',
     slug: 'al-capone',
@@ -19,8 +43,8 @@ afterEach(async () => {
   await factory.cleanDatabase()
 })
 
-describe('currentUser { notifications }', () => {
-  const query = gql`
+describe('notifications', () => {
+  const notificationQuery = gql`
     query($read: Boolean) {
       currentUser {
         notifications(read: $read, orderBy: createdAt_desc) {
@@ -34,77 +58,54 @@ describe('currentUser { notifications }', () => {
   `
 
   describe('authenticated', () => {
-    let headers
     beforeEach(async () => {
-      headers = await login({
-        email: 'test@example.org',
-        password: '1234',
-      })
-      client = new GraphQLClient(host, {
-        headers,
-      })
+      authenticatedUser = user
     })
 
     describe('given another user', () => {
-      let authorClient
-      let authorParams
-      let authorHeaders
-
+      let author
       beforeEach(async () => {
-        authorParams = {
+        author = await instance.create('User', {
           email: 'author@example.org',
           password: '1234',
           id: 'author',
-        }
-        await factory.create('User', authorParams)
-        authorHeaders = await login(authorParams)
+        })
       })
 
       describe('who mentions me in a post', () => {
-        let post
         const title = 'Mentioning Al Capone'
         const content =
           'Hey <a class="mention" data-mention-id="you" href="/profile/you/al-capone">@al-capone</a> how do you do?'
 
         beforeEach(async () => {
           const createPostMutation = gql`
-            mutation($title: String!, $content: String!) {
-              CreatePost(title: $title, content: $content) {
+            mutation($id: ID, $title: String!, $content: String!) {
+              CreatePost(id: $id, title: $title, content: $content) {
                 id
                 title
                 content
               }
             }
           `
-          authorClient = new GraphQLClient(host, {
-            headers: authorHeaders,
+          authenticatedUser = await author.toJson()
+          await mutate({
+            mutation: createPostMutation,
+            variables: { id: 'p47', title, content },
           })
-          const { CreatePost } = await authorClient.request(createPostMutation, {
-            title,
-            content,
-          })
-          post = CreatePost
+          authenticatedUser = await user.toJson()
         })
 
         it('sends you a notification', async () => {
           const expectedContent =
             'Hey <a class="mention" data-mention-id="you" href="/profile/you/al-capone" target="_blank">@al-capone</a> how do you do?'
-          const expected = {
-            currentUser: {
-              notifications: [
-                {
-                  read: false,
-                  post: {
-                    content: expectedContent,
-                  },
-                },
-              ],
+          const expected = expect.objectContaining({
+            data: {
+              currentUser: { notifications: [{ read: false, post: { content: expectedContent } }] },
             },
-          }
+          })
+          const { query } = createTestClient(server)
           await expect(
-            client.request(query, {
-              read: false,
-            }),
+            query({ query: notificationQuery, variables: { read: false } }),
           ).resolves.toEqual(expected)
         })
 
@@ -132,41 +133,33 @@ describe('currentUser { notifications }', () => {
                 }
               }
             `
-            authorClient = new GraphQLClient(host, {
-              headers: authorHeaders,
-            })
-            await authorClient.request(updatePostMutation, {
-              id: post.id,
-              title: post.title,
-              content: updatedContent,
+            authenticatedUser = await author.toJson()
+            await mutate({
+              mutation: updatePostMutation,
+              variables: {
+                id: 'p47',
+                title,
+                content: updatedContent,
+              },
             })
+            authenticatedUser = await user.toJson()
           })
 
           it('creates exactly one more notification', async () => {
             const expectedContent =
               '<br>One more mention to<br><a data-mention-id="you" class="mention" href="/profile/you" target="_blank"><br>@al-capone<br></a><br>and again:<br><a data-mention-id="you" class="mention" href="/profile/you" target="_blank"><br>@al-capone<br></a><br>and again<br><a data-mention-id="you" class="mention" href="/profile/you" target="_blank"><br>@al-capone<br></a><br>'
-            const expected = {
-              currentUser: {
-                notifications: [
-                  {
-                    read: false,
-                    post: {
-                      content: expectedContent,
-                    },
-                  },
-                  {
-                    read: false,
-                    post: {
-                      content: expectedContent,
-                    },
-                  },
-                ],
+            const expected = expect.objectContaining({
+              data: {
+                currentUser: {
+                  notifications: [
+                    { read: false, post: { content: expectedContent } },
+                    { read: false, post: { content: expectedContent } },
+                  ],
+                },
               },
-            }
+            })
             await expect(
-              client.request(query, {
-                read: false,
-              }),
+              query({ query: notificationQuery, variables: { read: false } }),
             ).resolves.toEqual(expected)
           })
         })
@@ -204,46 +197,40 @@ describe('Hashtags', () => {
   `
 
   describe('authenticated', () => {
-    let headers
     beforeEach(async () => {
-      headers = await login({
-        email: 'test@example.org',
-        password: '1234',
-      })
-      client = new GraphQLClient(host, {
-        headers,
-      })
+      authenticatedUser = await user.toJson()
     })
 
     describe('create a Post with Hashtags', () => {
       beforeEach(async () => {
-        await client.request(createPostMutation, {
-          postId,
-          postTitle,
-          postContent,
+        await mutate({
+          mutation: createPostMutation,
+          variables: {
+            postId,
+            postTitle,
+            postContent,
+          },
         })
       })
 
-      it('both Hashtags are created with the "id" set to thier "name"', async () => {
+      it('both Hashtags are created with the "id" set to their "name"', async () => {
         const expected = [
-          {
-            id: 'Democracy',
-            name: 'Democracy',
-          },
-          {
-            id: 'Liberty',
-            name: 'Liberty',
-          },
+          { id: 'Democracy', name: 'Democracy' },
+          { id: 'Liberty', name: 'Liberty' },
         ]
         await expect(
-          client.request(postWithHastagsQuery, postWithHastagsVariables),
-        ).resolves.toEqual({
-          Post: [
-            {
-              tags: expect.arrayContaining(expected),
+          query({ query: postWithHastagsQuery, variables: postWithHastagsVariables }),
+        ).resolves.toEqual(
+          expect.objectContaining({
+            data: {
+              Post: [
+                {
+                  tags: expect.arrayContaining(expected),
+                },
+              ],
             },
-          ],
-        })
+          }),
+        )
       })
 
       describe('afterwards update the Post by removing a Hashtag, leaving a Hashtag and add a Hashtag', () => {
@@ -261,31 +248,28 @@ describe('Hashtags', () => {
         `
 
         it('only one previous Hashtag and the new Hashtag exists', async () => {
-          await client.request(updatePostMutation, {
-            postId,
-            postTitle,
-            updatedPostContent,
+          await mutate({
+            mutation: updatePostMutation,
+            variables: {
+              postId,
+              postTitle,
+              updatedPostContent,
+            },
           })
 
           const expected = [
-            {
-              id: 'Elections',
-              name: 'Elections',
-            },
-            {
-              id: 'Liberty',
-              name: 'Liberty',
-            },
+            { id: 'Elections', name: 'Elections' },
+            { id: 'Liberty', name: 'Liberty' },
           ]
           await expect(
-            client.request(postWithHastagsQuery, postWithHastagsVariables),
-          ).resolves.toEqual({
-            Post: [
-              {
-                tags: expect.arrayContaining(expected),
+            query({ query: postWithHastagsQuery, variables: postWithHastagsVariables }),
+          ).resolves.toEqual(
+            expect.objectContaining({
+              data: {
+                Post: [{ tags: expect.arrayContaining(expected) }],
               },
-            ],
-          })
+            }),
+          )
         })
       })
     })
diff --git a/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.js b/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.js
index d08309f0b..e245e84b5 100644
--- a/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.js
+++ b/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.js
@@ -3,11 +3,13 @@ import cheerio from 'cheerio'
 export default function(content) {
   if (!content) return []
   const $ = cheerio.load(content)
-  let userIds = $('a.mention[data-mention-id]')
+  const userIds = $('a.mention[data-mention-id]')
     .map((_, el) => {
       return $(el).attr('data-mention-id')
     })
     .get()
-  userIds = userIds.map(id => id.trim()).filter(id => !!id)
   return userIds
+    .map(id => id.trim())
+    .filter(id => !!id)
+    .filter((id, index, allIds) => allIds.indexOf(id) === index)
 }
diff --git a/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.spec.js b/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.spec.js
index a631b64a3..9865eab0d 100644
--- a/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.spec.js
+++ b/backend/src/middleware/handleHtmlContent/notifications/extractMentionedUsers.spec.js
@@ -6,6 +6,8 @@ const contentEmptyMentions =
   '<p>Something inspirational about <a href="/profile/u2" data-mention-id="" target="_blank">@bob-der-baumeister</a> and <a href="/profile/u3/jenny-rostock" class="mention" data-mention-id target="_blank">@jenny-rostock</a>.</p>'
 const contentWithPlainLinks =
   '<p>Something inspirational about <a class="mention" href="/profile/u2" target="_blank">@bob-der-baumeister</a> and <a href="/profile/u3" target="_blank">@jenny-rostock</a>.</p>'
+const contentWithDuplicateIds =
+  'One more mention to <a data-mention-id="you" class="mention" href="/profile/you"> @al-capone </a> and again: <a data-mention-id="you" class="mention" href="/profile/you"> @al-capone </a> and again <a data-mention-id="you" class="mention" href="/profile/you"> @al-capone </a>'
 
 describe('extractMentionedUsers', () => {
   describe('content undefined', () => {
@@ -18,6 +20,10 @@ describe('extractMentionedUsers', () => {
     expect(extractMentionedUsers(contentWithPlainLinks)).toEqual([])
   })
 
+  it('removes duplicates', () => {
+    expect(extractMentionedUsers(contentWithDuplicateIds)).toEqual(['you'])
+  })
+
   describe('given a link with .mention class and `data-mention-id` attribute ', () => {
     it('extracts ids', () => {
       expect(extractMentionedUsers(contentWithMentions)).toEqual(['u3'])
diff --git a/backend/src/models/Notification.js b/backend/src/models/Notification.js
new file mode 100644
index 000000000..b8690b8c1
--- /dev/null
+++ b/backend/src/models/Notification.js
@@ -0,0 +1,19 @@
+import uuid from 'uuid/v4'
+
+module.exports = {
+  id: { type: 'uuid', primary: true, default: uuid },
+  createdAt: { type: 'string', isoDate: true, default: () => new Date().toISOString() },
+  read: { type: 'boolean', default: false },
+  user: {
+    type: 'relationship',
+    relationship: 'NOTIFIED',
+    target: 'User',
+    direction: 'out',
+  },
+  post: {
+    type: 'relationship',
+    relationship: 'NOTIFIED',
+    target: 'Post',
+    direction: 'in',
+  },
+}
diff --git a/backend/src/models/User.js b/backend/src/models/User.js
index 3dfcef06a..fa578f8ad 100644
--- a/backend/src/models/User.js
+++ b/backend/src/models/User.js
@@ -77,4 +77,10 @@ module.exports = {
     target: 'User',
     direction: 'out',
   },
+  notifications: {
+    type: 'relationship',
+    relationship: 'NOTIFIED',
+    target: 'Notification',
+    direction: 'in',
+  },
 }
diff --git a/backend/src/models/index.js b/backend/src/models/index.js
index b8dc451d7..6f6b300f8 100644
--- a/backend/src/models/index.js
+++ b/backend/src/models/index.js
@@ -7,4 +7,5 @@ export default {
   EmailAddress: require('./EmailAddress.js'),
   SocialMedia: require('./SocialMedia.js'),
   Post: require('./Post.js'),
+  Notification: require('./Notification.js'),
 }
diff --git a/backend/src/schema/types/schema.gql b/backend/src/schema/types/schema.gql
index 41fe8f4e6..b8e5f5290 100644
--- a/backend/src/schema/types/schema.gql
+++ b/backend/src/schema/types/schema.gql
@@ -50,14 +50,6 @@ type Statistics {
   countShouts: Int!
 }
 
-type Notification {
-  id: ID!
-  read: Boolean
-  user: User @relation(name: "NOTIFIED", direction: "OUT")
-  post: Post @relation(name: "NOTIFIED", direction: "IN")
-  createdAt: String
-}
-
 type Location {
   id: ID!
   name: String!
diff --git a/backend/src/schema/types/type/Notification.gql b/backend/src/schema/types/type/Notification.gql
new file mode 100644
index 000000000..e4bc16fec
--- /dev/null
+++ b/backend/src/schema/types/type/Notification.gql
@@ -0,0 +1,7 @@
+type Notification {
+  id: ID!
+  read: Boolean
+  user: User @relation(name: "NOTIFIED", direction: "OUT")
+  post: Post @relation(name: "NOTIFIED", direction: "IN")
+  createdAt: String
+}

From 5103bdbc2a818f74c4caede1b6aea9b63a5171ab Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 11:50:33 +0200
Subject: [PATCH 16/26] Fix tests

---
 .../src/middleware/orderByMiddleware.spec.js  | 71 ++++++++++++-------
 backend/src/schema/resolvers/posts.js         |  1 +
 backend/src/schema/resolvers/posts.spec.js    |  2 +
 3 files changed, 48 insertions(+), 26 deletions(-)

diff --git a/backend/src/middleware/orderByMiddleware.spec.js b/backend/src/middleware/orderByMiddleware.spec.js
index 450220cd6..7a42166cf 100644
--- a/backend/src/middleware/orderByMiddleware.spec.js
+++ b/backend/src/middleware/orderByMiddleware.spec.js
@@ -1,22 +1,29 @@
-import { GraphQLClient } from 'graphql-request'
 import Factory from '../seed/factories'
-import { host } from '../jest/helpers'
+import { gql } from '../jest/helpers'
+import { neode as getNeode, getDriver } from '../bootstrap/neo4j'
+import { createTestClient } from 'apollo-server-testing'
+import createServer from '../server'
 
-let client
-let headers
-let query
 const factory = Factory()
+const neode = getNeode()
+const driver = getDriver()
+
+const { server } = createServer({
+  context: () => {
+    return {
+      user: null,
+      neode,
+      driver,
+    }
+  },
+})
+const { query } = createTestClient(server)
 
 beforeEach(async () => {
-  const userParams = { name: 'Author', email: 'author@example.org', password: '1234' }
-  await factory.create('User', userParams)
-  await factory.authenticateAs(userParams)
-  await factory.create('Post', { title: 'first' })
-  await factory.create('Post', { title: 'second' })
-  await factory.create('Post', { title: 'third' })
-  await factory.create('Post', { title: 'last' })
-  headers = {}
-  client = new GraphQLClient(host, { headers })
+  await neode.create('Post', { title: 'first' })
+  await neode.create('Post', { title: 'second' })
+  await neode.create('Post', { title: 'third' })
+  await neode.create('Post', { title: 'last' })
 })
 
 afterEach(async () => {
@@ -25,10 +32,6 @@ afterEach(async () => {
 
 describe('Query', () => {
   describe('Post', () => {
-    beforeEach(() => {
-      query = '{ Post { title } }'
-    })
-
     describe('orderBy', () => {
       it('createdAt descending is default', async () => {
         const posts = [
@@ -37,15 +40,21 @@ describe('Query', () => {
           { title: 'second' },
           { title: 'first' },
         ]
-        const expected = { Post: posts }
-        await expect(client.request(query)).resolves.toEqual(expected)
+        const expected = expect.objectContaining({ data: { Post: posts } })
+        await expect(
+          query({
+            query: gql`
+              {
+                Post {
+                  title
+                }
+              }
+            `,
+          }),
+        ).resolves.toEqual(expected)
       })
 
       describe('(orderBy: createdAt_asc)', () => {
-        beforeEach(() => {
-          query = '{ Post(orderBy: createdAt_asc) { title } }'
-        })
-
         it('orders by createdAt ascending', async () => {
           const posts = [
             { title: 'first' },
@@ -53,8 +62,18 @@ describe('Query', () => {
             { title: 'third' },
             { title: 'last' },
           ]
-          const expected = { Post: posts }
-          await expect(client.request(query)).resolves.toEqual(expected)
+          const expected = expect.objectContaining({ data: { Post: posts } })
+          await expect(
+            query({
+              query: gql`
+                {
+                  Post(orderBy: createdAt_asc) {
+                    title
+                  }
+                }
+              `,
+            }),
+          ).resolves.toEqual(expected)
         })
       })
     })
diff --git a/backend/src/schema/resolvers/posts.js b/backend/src/schema/resolvers/posts.js
index 884bd4659..ea1f680bd 100644
--- a/backend/src/schema/resolvers/posts.js
+++ b/backend/src/schema/resolvers/posts.js
@@ -5,6 +5,7 @@ import { getBlockedUsers, getBlockedByUsers } from './users.js'
 import { mergeWith, isArray } from 'lodash'
 
 const filterForBlockedUsers = async (params, context) => {
+  if (!context.user) return params
   const [blockedUsers, blockedByUsers] = await Promise.all([
     getBlockedUsers(context),
     getBlockedByUsers(context),
diff --git a/backend/src/schema/resolvers/posts.spec.js b/backend/src/schema/resolvers/posts.spec.js
index b48be16db..15376c8a4 100644
--- a/backend/src/schema/resolvers/posts.spec.js
+++ b/backend/src/schema/resolvers/posts.spec.js
@@ -460,6 +460,7 @@ describe('emotions', () => {
         context: () => {
           return {
             user,
+            neode: instance,
             driver,
           }
         },
@@ -476,6 +477,7 @@ describe('emotions', () => {
         context: () => {
           return {
             user,
+            neode: instance,
             driver,
           }
         },

From 717147bd0ca59aeecf69b7788d887bafa4ddbd71 Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 16:05:57 +0200
Subject: [PATCH 17/26] Refetch posts list if you block a user

Because you won't see any posts of a blocked user
---
 webapp/pages/profile/_id/_slug.vue | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/webapp/pages/profile/_id/_slug.vue b/webapp/pages/profile/_id/_slug.vue
index a807740d0..0e15218c8 100644
--- a/webapp/pages/profile/_id/_slug.vue
+++ b/webapp/pages/profile/_id/_slug.vue
@@ -382,10 +382,13 @@ export default {
     },
     async block(user) {
       await this.$apollo.mutate({ mutation: Block(), variables: { id: user.id } })
-      await this.fetchUser()
+      this.$apollo.queries.User.refetch()
+      this.$apollo.queries.Post.refetch()
     },
     async unblock(user) {
       await this.$apollo.mutate({ mutation: Unblock(), variables: { id: user.id } })
+      this.$apollo.queries.User.refetch()
+      this.$apollo.queries.Post.refetch()
     },
   },
   apollo: {

From 6fb926e735d14eb3438b616f0942f04e9db51514 Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 16:46:52 +0200
Subject: [PATCH 18/26] Fix Search.feature in a hacky way

Ok, we have no control what parameters are passed to the cypher query
generated by `neo4j-graphql-js`. So I'm re-using the `filter` param.
If the `$filter` param is `{}` then we can use COALESCE to turn that
into empty array. Ugh.
---
 backend/src/schema/types/schema.gql | 5 +++--
 webapp/store/search.js              | 6 +++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/backend/src/schema/types/schema.gql b/backend/src/schema/types/schema.gql
index b8e5f5290..560669a7d 100644
--- a/backend/src/schema/types/schema.gql
+++ b/backend/src/schema/types/schema.gql
@@ -4,15 +4,16 @@ type Query {
   currentUser: User
   # Get the latest Network Statistics
   statistics: Statistics!
-  findPosts(filter: String!, limit: Int = 10): [Post]!
+  findPosts(query: String!, limit: Int = 10): [Post]!
     @cypher(
       statement: """
-      CALL db.index.fulltext.queryNodes('full_text_search', $filter)
+      CALL db.index.fulltext.queryNodes('full_text_search', $query)
       YIELD node as post, score
       MATCH (post)<-[:WROTE]-(user:User)
       WHERE score >= 0.2
       AND NOT user.deleted = true AND NOT user.disabled = true
       AND NOT post.deleted = true AND NOT post.disabled = true
+      AND NOT user.id in COALESCE($filter.author_not.id_in, [])
       RETURN post
       LIMIT $limit
       """
diff --git a/webapp/store/search.js b/webapp/store/search.js
index 4aeb5030d..c5ed9523a 100644
--- a/webapp/store/search.js
+++ b/webapp/store/search.js
@@ -46,8 +46,8 @@ export const actions = {
     await this.app.apolloProvider.defaultClient
       .query({
         query: gql(`
-          query findPosts($filter: String!) {
-            findPosts(filter: $filter, limit: 10) {
+          query findPosts($query: String!) {
+            findPosts(query: $query, limit: 10) {
               id
               slug
               label: title
@@ -64,7 +64,7 @@ export const actions = {
           }
         `),
         variables: {
-          filter: value.replace(/\s/g, '~ ') + '~',
+          query: value.replace(/\s/g, '~ ') + '~',
         },
       })
       .then(res => {

From d2a6d8c047ced72dc9f4073d5d61b2daa1c368fd Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 17:15:55 +0200
Subject: [PATCH 19/26] Avoid notifications if user was blocked

Otherwise you would follow a link and get a 404
---
 .../handleHtmlContent/handleContentData.js    | 11 ++++----
 .../handleContentData.spec.js                 | 28 ++++++++++++++++---
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/backend/src/middleware/handleHtmlContent/handleContentData.js b/backend/src/middleware/handleHtmlContent/handleContentData.js
index 6519ddae7..287ba34e6 100644
--- a/backend/src/middleware/handleHtmlContent/handleContentData.js
+++ b/backend/src/middleware/handleHtmlContent/handleContentData.js
@@ -5,11 +5,12 @@ const notify = async (postId, idsOfMentionedUsers, context) => {
   const session = context.driver.session()
   const createdAt = new Date().toISOString()
   const cypher = `
-    match(u:User) where u.id in $idsOfMentionedUsers
-    match(p:Post) where p.id = $postId
-    create(n:Notification{id: apoc.create.uuid(), read: false, createdAt: $createdAt})
-    merge (n)-[:NOTIFIED]->(u)
-    merge (p)-[:NOTIFIED]->(n)
+    MATCH(p:Post {id: $postId})<-[:WROTE]-(author:User)
+    MATCH(u:User)
+    WHERE u.id in $idsOfMentionedUsers
+    AND NOT (u)<-[:BLOCKED]-(author)
+    CREATE(n:Notification{id: apoc.create.uuid(), read: false, createdAt: $createdAt})
+    MERGE (p)-[:NOTIFIED]->(n)-[:NOTIFIED]->(u)
     `
   await session.run(cypher, {
     idsOfMentionedUsers,
diff --git a/backend/src/middleware/handleHtmlContent/handleContentData.spec.js b/backend/src/middleware/handleHtmlContent/handleContentData.spec.js
index 1effeb5d6..40d8a2481 100644
--- a/backend/src/middleware/handleHtmlContent/handleContentData.spec.js
+++ b/backend/src/middleware/handleHtmlContent/handleContentData.spec.js
@@ -77,7 +77,7 @@ describe('notifications', () => {
         const content =
           'Hey <a class="mention" data-mention-id="you" href="/profile/you/al-capone">@al-capone</a> how do you do?'
 
-        beforeEach(async () => {
+        const createPostAction = async () => {
           const createPostMutation = gql`
             mutation($id: ID, $title: String!, $content: String!) {
               CreatePost(id: $id, title: $title, content: $content) {
@@ -93,9 +93,10 @@ describe('notifications', () => {
             variables: { id: 'p47', title, content },
           })
           authenticatedUser = await user.toJson()
-        })
+        }
 
         it('sends you a notification', async () => {
+          await createPostAction()
           const expectedContent =
             'Hey <a class="mention" data-mention-id="you" href="/profile/you/al-capone" target="_blank">@al-capone</a> how do you do?'
           const expected = expect.objectContaining({
@@ -110,7 +111,7 @@ describe('notifications', () => {
         })
 
         describe('who mentions me many times', () => {
-          beforeEach(async () => {
+          const updatePostAction = async () => {
             const updatedContent = `
               One more mention to
               <a data-mention-id="you" class="mention" href="/profile/you">
@@ -143,9 +144,11 @@ describe('notifications', () => {
               },
             })
             authenticatedUser = await user.toJson()
-          })
+          }
 
           it('creates exactly one more notification', async () => {
+            await createPostAction()
+            await updatePostAction()
             const expectedContent =
               '<br>One more mention to<br><a data-mention-id="you" class="mention" href="/profile/you" target="_blank"><br>@al-capone<br></a><br>and again:<br><a data-mention-id="you" class="mention" href="/profile/you" target="_blank"><br>@al-capone<br></a><br>and again<br><a data-mention-id="you" class="mention" href="/profile/you" target="_blank"><br>@al-capone<br></a><br>'
             const expected = expect.objectContaining({
@@ -163,6 +166,23 @@ describe('notifications', () => {
             ).resolves.toEqual(expected)
           })
         })
+
+        describe('but the author of the post blocked me', () => {
+          beforeEach(async () => {
+            await author.relateTo(user, 'blocked')
+          })
+
+          it('sends no notification', async () => {
+            await createPostAction()
+            const expected = expect.objectContaining({
+              data: { currentUser: { notifications: [] } },
+            })
+            const { query } = createTestClient(server)
+            await expect(
+              query({ query: notificationQuery, variables: { read: false } }),
+            ).resolves.toEqual(expected)
+          })
+        })
       })
     })
   })

From fffd29e867ac743af75d07410b1ddb06275529aa Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 17:58:31 +0200
Subject: [PATCH 20/26] Sketch cucumber scenarios for blocked user feature

.. first scenario already passing
---
 cypress/integration/common/steps.js           | 28 ++++++++++++
 .../user_profile/BlockedUser.feature          | 44 +++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 cypress/integration/user_profile/BlockedUser.feature

diff --git a/cypress/integration/common/steps.js b/cypress/integration/common/steps.js
index 387273eff..5ff64fb1c 100644
--- a/cypress/integration/common/steps.js
+++ b/cypress/integration/common/steps.js
@@ -362,3 +362,31 @@ Then("the notification gets marked as read", () => {
 Then("there are no notifications in the top menu", () => {
   cy.get(".notifications-menu").should("contain", "0");
 });
+
+Given("there is an annoying user called {string}", (name) => {
+  cy.factory().create('User', { id: 'annoying-user', name })
+})
+
+Given("I am on the profile page of the annoying user", (name) => {
+  cy.openPage('/profile/annoying-user');
+})
+
+When("I ", (name) => {
+  cy.openPage('/profile/annoying-user');
+})
+
+When("I click on {string} from the content menu in the user info box", (button) => {
+  cy.get('.user-content-menu .content-menu-trigger')
+    .click()
+  cy.get('.popover .ds-menu-item-link')
+    .contains(button)
+    .click()
+})
+
+
+When ("I navigate to my {string} settings page", (settingsPage) => {
+  cy.get(".avatar-menu").click();
+  cy.get(".avatar-menu-popover")
+    .find('a[href]').contains("Settings").click()
+  cy.contains('.ds-menu-item-link', settingsPage).click()
+})
diff --git a/cypress/integration/user_profile/BlockedUser.feature b/cypress/integration/user_profile/BlockedUser.feature
new file mode 100644
index 000000000..41d88226f
--- /dev/null
+++ b/cypress/integration/user_profile/BlockedUser.feature
@@ -0,0 +1,44 @@
+Feature: Block another user
+  As a user
+  I'd like to have a button to block another user
+  To prevent him to see and interact with my contributions and also to avoid to see his/her posts
+
+  Background:
+    Given I have a user account
+    And there is an annoying user called "Spammy Spammer"
+    And I am logged in
+
+  Scenario: Block a user
+    Given I am on the profile page of the annoying user
+    When I click on "Block User" from the content menu in the user info box
+    And I navigate to my "Blocked users" settings page
+    Then I can see the following table:
+      | Avatar        | Name           |
+      |               | Spammy Spammer |
+
+  Scenario Outline: Blocked users cannot see each others posts
+    Given "Spammy Spammer" wrote a post "Spam Spam Spam"
+    And I wrote a post "I hate spammers"
+    And I block the user "Spammy Spammer"
+    When I log in with <account>
+    Then I see only one post with the title <expected_title>
+    Examples:
+      | accout                  | expected_title  |
+      | my own account          | I hate spammers |
+      | spammy spammers account | Spam Spam Spam  |
+
+  Scenario: Block a previously followed user
+    Given I follow the user "Spammy Spammer"
+    When I visit the profile page of the annoying user
+    And I click on "Block User" from the content menu in the user info box
+    Then the list of posts of this user is empty
+    And nobody is following the user profile anymore
+
+  Scenario: Posts of blocked users are filtered from search results
+    Given "Spammy Spammer" wrote a post "Spam Spam Spam"
+    When I search for "Spam"
+    Then I should see the following posts in the select dropdown:
+      | title          |
+      | Spam Spam Spam |
+    But if I block the user "Spammy Spammer"
+    Then the search has no results

From b017203c64716effd0f21cfe99b94df7fda306f5 Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 19:09:56 +0200
Subject: [PATCH 21/26] Implement next cucumber scenario

---
 cypress/integration/common/steps.js | 43 +++++++++++++++++++++++++++--
 cypress/support/factories.js        | 21 +++++++++++++-
 2 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/cypress/integration/common/steps.js b/cypress/integration/common/steps.js
index 5ff64fb1c..f0446fcc6 100644
--- a/cypress/integration/common/steps.js
+++ b/cypress/integration/common/steps.js
@@ -364,13 +364,25 @@ Then("there are no notifications in the top menu", () => {
 });
 
 Given("there is an annoying user called {string}", (name) => {
-  cy.factory().create('User', { id: 'annoying-user', name })
+  const annoyingParams = {
+    email: 'spammy-spammer@example.org',
+    password: '1234',
+  }
+  cy.factory().create('User', {
+    ...annoyingParams,
+    id: 'annoying-user',
+    name
+  })
 })
 
 Given("I am on the profile page of the annoying user", (name) => {
   cy.openPage('/profile/annoying-user');
 })
 
+When("I visit the profile page of the annoying user", (name) => {
+  cy.openPage('/profile/annoying-user');
+})
+
 When("I ", (name) => {
   cy.openPage('/profile/annoying-user');
 })
@@ -383,10 +395,37 @@ When("I click on {string} from the content menu in the user info box", (button)
     .click()
 })
 
-
 When ("I navigate to my {string} settings page", (settingsPage) => {
   cy.get(".avatar-menu").click();
   cy.get(".avatar-menu-popover")
     .find('a[href]').contains("Settings").click()
   cy.contains('.ds-menu-item-link', settingsPage).click()
 })
+
+Given("I follow the user {string}", (name) => {
+  cy.neode()
+    .first('User', { name }).then((followed) => {
+      cy.neode()
+        .first('User', {name: narratorParams.name})
+        .relateTo(followed, 'following')
+    })
+})
+
+Given("\"Spammy Spammer\" wrote a post {string}", (title) => {
+  cy.factory()
+    .authenticateAs({
+      email: 'spammy-spammer@example.org',
+      password: '1234',
+    })
+    .create("Post", { title })
+})
+
+Then("the list of posts of this user is empty", () => {
+  cy.get('.ds-card-content').not('.post-link')
+  cy.get('.main-container').find('.ds-space.hc-empty')
+})
+
+Then("nobody is following the user profile anymore", () => {
+  cy.get('.ds-card-content').not('.post-link')
+  cy.get('.main-container').contains('.ds-card-content', 'is not followed by anyone')
+})
diff --git a/cypress/support/factories.js b/cypress/support/factories.js
index 825f65b83..237d057cf 100644
--- a/cypress/support/factories.js
+++ b/cypress/support/factories.js
@@ -1,5 +1,5 @@
 import Factory from '../../backend/src/seed/factories'
-import { getDriver } from '../../backend/src/bootstrap/neo4j'
+import { getDriver, neode as getNeode } from '../../backend/src/bootstrap/neo4j'
 import setupNeode from '../../backend/src/bootstrap/neode'
 import neode from 'neode'
 
@@ -16,6 +16,25 @@ beforeEach(async () => {
   await factory.cleanDatabase({ seedServerHost, neo4jDriver })
 })
 
+Cypress.Commands.add('neode', () => {
+  return setupNeode(neo4jConfigs)
+})
+Cypress.Commands.add(
+  'first',
+  { prevSubject: true },
+  async (neode, model, properties) => {
+    console.log(neode)
+    return neode.first(model, properties)
+  }
+)
+Cypress.Commands.add(
+  'relateTo',
+  { prevSubject: true },
+  async (node, otherNode, relationship) => {
+    return node.relateTo(otherNode, relationship)
+  }
+)
+
 Cypress.Commands.add('factory', () => {
   return Factory({ seedServerHost, neo4jDriver, neodeInstance: setupNeode(neo4jConfigs) })
 })

From 073185d424cad35e5c979706c0d1e42f2799ff91 Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 19:46:01 +0200
Subject: [PATCH 22/26] All cucumbers implemented

---
 cypress/integration/common/search.js          |  7 +++
 cypress/integration/common/steps.js           | 28 +++++++++++-
 .../user_profile/BlockedUser.feature          | 44 -------------------
 .../blocked-users/Blocking.feature            | 36 +++++++++++++++
 .../blocked-users/Content.feature             | 22 ++++++++++
 cypress/support/factories.js                  |  1 -
 6 files changed, 92 insertions(+), 46 deletions(-)
 delete mode 100644 cypress/integration/user_profile/BlockedUser.feature
 create mode 100644 cypress/integration/user_profile/blocked-users/Blocking.feature
 create mode 100644 cypress/integration/user_profile/blocked-users/Content.feature

diff --git a/cypress/integration/common/search.js b/cypress/integration/common/search.js
index 5a3819a9d..35b2d1346 100644
--- a/cypress/integration/common/search.js
+++ b/cypress/integration/common/search.js
@@ -11,6 +11,13 @@ Then("I should have one post in the select dropdown", () => {
   });
 });
 
+Then("the search has no results", () => {
+  cy.get(".input .ds-select-dropdown").should($li => {
+    expect($li).to.have.length(1);
+  });
+  cy.get(".ds-select-dropdown").should("contain", 'Nothing found');
+});
+
 Then("I should see the following posts in the select dropdown:", table => {
   table.hashes().forEach(({ title }) => {
     cy.get(".ds-select-dropdown").should("contain", title);
diff --git a/cypress/integration/common/steps.js b/cypress/integration/common/steps.js
index f0446fcc6..e1eab98c1 100644
--- a/cypress/integration/common/steps.js
+++ b/cypress/integration/common/steps.js
@@ -376,7 +376,7 @@ Given("there is an annoying user called {string}", (name) => {
 })
 
 Given("I am on the profile page of the annoying user", (name) => {
-  cy.openPage('/profile/annoying-user');
+  cy.openPage('/profile/annoying-user/spammy-spammer');
 })
 
 When("I visit the profile page of the annoying user", (name) => {
@@ -429,3 +429,29 @@ Then("nobody is following the user profile anymore", () => {
   cy.get('.ds-card-content').not('.post-link')
   cy.get('.main-container').contains('.ds-card-content', 'is not followed by anyone')
 })
+
+Given("I wrote a post {string}", (title) => {
+  cy.factory()
+    .authenticateAs(loginCredentials)
+    .create("Post", { title })
+})
+
+When("I block the user {string}", (name) => {
+  cy.neode()
+    .first('User', { name }).then((blocked) => {
+      cy.neode()
+        .first('User', {name: narratorParams.name})
+        .relateTo(blocked, 'blocked')
+    })
+})
+
+When("I log in with:", (table) => {
+  const [firstRow] = table.hashes()
+  const { Email, Password } = firstRow
+  cy.login({email: Email, password: Password})
+})
+
+Then("I see only one post with the title {string}", (title) => {
+  cy.get('.main-container').find('.post-link').should('have.length', 1)
+  cy.get('.main-container').contains('.post-link', title)
+})
diff --git a/cypress/integration/user_profile/BlockedUser.feature b/cypress/integration/user_profile/BlockedUser.feature
deleted file mode 100644
index 41d88226f..000000000
--- a/cypress/integration/user_profile/BlockedUser.feature
+++ /dev/null
@@ -1,44 +0,0 @@
-Feature: Block another user
-  As a user
-  I'd like to have a button to block another user
-  To prevent him to see and interact with my contributions and also to avoid to see his/her posts
-
-  Background:
-    Given I have a user account
-    And there is an annoying user called "Spammy Spammer"
-    And I am logged in
-
-  Scenario: Block a user
-    Given I am on the profile page of the annoying user
-    When I click on "Block User" from the content menu in the user info box
-    And I navigate to my "Blocked users" settings page
-    Then I can see the following table:
-      | Avatar        | Name           |
-      |               | Spammy Spammer |
-
-  Scenario Outline: Blocked users cannot see each others posts
-    Given "Spammy Spammer" wrote a post "Spam Spam Spam"
-    And I wrote a post "I hate spammers"
-    And I block the user "Spammy Spammer"
-    When I log in with <account>
-    Then I see only one post with the title <expected_title>
-    Examples:
-      | accout                  | expected_title  |
-      | my own account          | I hate spammers |
-      | spammy spammers account | Spam Spam Spam  |
-
-  Scenario: Block a previously followed user
-    Given I follow the user "Spammy Spammer"
-    When I visit the profile page of the annoying user
-    And I click on "Block User" from the content menu in the user info box
-    Then the list of posts of this user is empty
-    And nobody is following the user profile anymore
-
-  Scenario: Posts of blocked users are filtered from search results
-    Given "Spammy Spammer" wrote a post "Spam Spam Spam"
-    When I search for "Spam"
-    Then I should see the following posts in the select dropdown:
-      | title          |
-      | Spam Spam Spam |
-    But if I block the user "Spammy Spammer"
-    Then the search has no results
diff --git a/cypress/integration/user_profile/blocked-users/Blocking.feature b/cypress/integration/user_profile/blocked-users/Blocking.feature
new file mode 100644
index 000000000..6a106fc9e
--- /dev/null
+++ b/cypress/integration/user_profile/blocked-users/Blocking.feature
@@ -0,0 +1,36 @@
+Feature: Block a User
+  As a user
+  I'd like to have a button to block another user
+  To prevent him to see and interact with my contributions and also to avoid to see his/her posts
+
+  Background:
+    Given I have a user account
+    And there is an annoying user called "Spammy Spammer"
+    And I am logged in
+
+    Scenario: Block a user
+      Given I am on the profile page of the annoying user
+      When I click on "Block User" from the content menu in the user info box
+      And I navigate to my "Blocked users" settings page
+      Then I can see the following table:
+        | Avatar        | Name           |
+        |               | Spammy Spammer |
+
+    Scenario: Block a previously followed user
+      Given I follow the user "Spammy Spammer"
+      And "Spammy Spammer" wrote a post "Spam Spam Spam"
+      When I visit the profile page of the annoying user
+      And I click on "Block User" from the content menu in the user info box
+      Then the list of posts of this user is empty
+      And nobody is following the user profile anymore
+
+    Scenario: Posts of blocked users are filtered from search results
+      Given "Spammy Spammer" wrote a post "Spam Spam Spam"
+      When I search for "Spam"
+      Then I should see the following posts in the select dropdown:
+        | title          |
+        | Spam Spam Spam |
+      When I block the user "Spammy Spammer"
+      And I refresh the page
+      And I search for "Spam"
+      Then the search has no results
diff --git a/cypress/integration/user_profile/blocked-users/Content.feature b/cypress/integration/user_profile/blocked-users/Content.feature
new file mode 100644
index 000000000..8bbad7e8c
--- /dev/null
+++ b/cypress/integration/user_profile/blocked-users/Content.feature
@@ -0,0 +1,22 @@
+Feature: Block a User
+  As a user
+  I'd like to have a button to block another user
+  To prevent him to see and interact with my contributions and also to avoid to see his/her posts
+
+  Background:
+    Given I have a user account
+    And there is an annoying user called "Spammy Spammer"
+
+   Scenario Outline: Blocked users cannot see each others posts
+     Given "Spammy Spammer" wrote a post "Spam Spam Spam"
+     And I wrote a post "I hate spammers"
+     And I block the user "Spammy Spammer"
+     When I log in with:
+       | Email | Password |
+       | <email> | <password> |
+     Then I see only one post with the title "<expected_title>"
+     Examples:
+       | email                      | password | expected_title  |
+       | peterpan@example.org       | 1234     | I hate spammers |
+       | spammy-spammer@example.org | 1234     | Spam Spam Spam  |
+
diff --git a/cypress/support/factories.js b/cypress/support/factories.js
index 237d057cf..20a4d4c77 100644
--- a/cypress/support/factories.js
+++ b/cypress/support/factories.js
@@ -23,7 +23,6 @@ Cypress.Commands.add(
   'first',
   { prevSubject: true },
   async (neode, model, properties) => {
-    console.log(neode)
     return neode.first(model, properties)
   }
 )

From 6b884d84c153de39b85c17e49c718b22620afd46 Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Tue, 13 Aug 2019 19:56:01 +0200
Subject: [PATCH 23/26] Add translations

---
 webapp/locales/de.json                  | 2 ++
 webapp/locales/en.json                  | 2 ++
 webapp/pages/settings/blocked-users.vue | 6 ++++++
 3 files changed, 10 insertions(+)

diff --git a/webapp/locales/de.json b/webapp/locales/de.json
index 13fdfe824..a94d19f2f 100644
--- a/webapp/locales/de.json
+++ b/webapp/locales/de.json
@@ -196,6 +196,8 @@
         "intro": "Wenn ein anderer Benutzer von dir blockiert wurde, dann passiert folgendes:",
         "your-perspective": "In deiner Beitragsübersicht tauchen keine Beiträge der blockierten Person mehr auf.",
         "their-perspective": "Umgekehrt das gleiche: Die blockierte Person sieht deine Beiträge auch nicht mehr in ihrer Übersicht.",
+        "search": "Die Beiträge von blockierten Personen verschwinden aus deinen Suchergebnissen.",
+        "notifications": "Von dir blockierte Personen erhalten keine Benachrichtigungen mehr, wenn sie in deinen Beiträgen erwähnt werden.",
         "closing": "Das sollte fürs Erste genügen, damit blockierte Benutzer dich nicht mehr länger belästigen können."
       },
       "columns": {
diff --git a/webapp/locales/en.json b/webapp/locales/en.json
index 70dbae8ce..03724e7cf 100644
--- a/webapp/locales/en.json
+++ b/webapp/locales/en.json
@@ -196,6 +196,8 @@
         "intro": "If another user has been blocked by you, this is what happens:",
         "your-perspective": "The blocked person's posts will no longer appear in your news feed.",
         "their-perspective": "Vice versa: The blocked person will also no longer see your posts in their news feed.",
+        "search": "Posts of blocked people disappear from your search results.",
+        "notifications": "Blocked users will no longer receive notifications if they are mentioned in your posts.",
         "closing": "This should be sufficient for now so that blocked users can no longer bother you."
 
       },
diff --git a/webapp/pages/settings/blocked-users.vue b/webapp/pages/settings/blocked-users.vue
index 2969328fe..17b8ee3d5 100644
--- a/webapp/pages/settings/blocked-users.vue
+++ b/webapp/pages/settings/blocked-users.vue
@@ -12,6 +12,12 @@
           <ds-list-item>
             {{ $t('settings.blocked-users.explanation.their-perspective') }}
           </ds-list-item>
+          <ds-list-item>
+            {{ $t('settings.blocked-users.explanation.search') }}
+          </ds-list-item>
+          <ds-list-item>
+            {{ $t('settings.blocked-users.explanation.notifications') }}
+          </ds-list-item>
         </ds-list>
         <ds-text>
           {{ $t('settings.blocked-users.explanation.closing') }}

From 31299235a3850e47ed885cf71579c3117da52dac Mon Sep 17 00:00:00 2001
From: roschaefer <gitkraken@roschaefer.de>
Date: Wed, 14 Aug 2019 00:11:45 +0200
Subject: [PATCH 24/26] Better caching policy on the blocked users page

Read: https://medium.com/@galen.corey/understanding-apollo-fetch-policies-705b5ad71980
for the difference. I think it's exactly what we need to update the
blocked users as soon as we switch to the page.
---
 webapp/pages/settings/blocked-users.vue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/webapp/pages/settings/blocked-users.vue b/webapp/pages/settings/blocked-users.vue
index 17b8ee3d5..19e24c994 100644
--- a/webapp/pages/settings/blocked-users.vue
+++ b/webapp/pages/settings/blocked-users.vue
@@ -96,7 +96,7 @@ export default {
     },
   },
   apollo: {
-    blockedUsers: { query: BlockedUsers },
+    blockedUsers: { query: BlockedUsers, fetchPolicy: 'cache-and-network' },
   },
 }
 </script>

From 6099a986c92545c8ec10638ccf0f3098469d3f3e Mon Sep 17 00:00:00 2001
From: Matt Rider <mattwr18@gmail.com>
Date: Wed, 14 Aug 2019 14:29:35 +0200
Subject: [PATCH 25/26] Improve English, update case for English translations

---
 .../blocked-users/Blocking.feature            | 50 +++++++++----------
 .../blocked-users/Content.feature             | 26 +++++-----
 webapp/locales/en.json                        |  5 +-
 3 files changed, 40 insertions(+), 41 deletions(-)

diff --git a/cypress/integration/user_profile/blocked-users/Blocking.feature b/cypress/integration/user_profile/blocked-users/Blocking.feature
index 6a106fc9e..07d84d7bf 100644
--- a/cypress/integration/user_profile/blocked-users/Blocking.feature
+++ b/cypress/integration/user_profile/blocked-users/Blocking.feature
@@ -1,36 +1,36 @@
 Feature: Block a User
   As a user
   I'd like to have a button to block another user
-  To prevent him to see and interact with my contributions and also to avoid to see his/her posts
+  To prevent him from seeing and interacting with my contributions and also to avoid seeing his/her posts
 
   Background:
     Given I have a user account
     And there is an annoying user called "Spammy Spammer"
     And I am logged in
 
-    Scenario: Block a user
-      Given I am on the profile page of the annoying user
-      When I click on "Block User" from the content menu in the user info box
-      And I navigate to my "Blocked users" settings page
-      Then I can see the following table:
-        | Avatar        | Name           |
-        |               | Spammy Spammer |
+  Scenario: Block a user
+    Given I am on the profile page of the annoying user
+    When I click on "Block User" from the content menu in the user info box
+    And I navigate to my "Blocked users" settings page
+    Then I can see the following table:
+      | Avatar | Name           |
+      |        | Spammy Spammer |
 
-    Scenario: Block a previously followed user
-      Given I follow the user "Spammy Spammer"
-      And "Spammy Spammer" wrote a post "Spam Spam Spam"
-      When I visit the profile page of the annoying user
-      And I click on "Block User" from the content menu in the user info box
-      Then the list of posts of this user is empty
-      And nobody is following the user profile anymore
+  Scenario: Block a previously followed user
+    Given I follow the user "Spammy Spammer"
+    And "Spammy Spammer" wrote a post "Spam Spam Spam"
+    When I visit the profile page of the annoying user
+    And I click on "Block User" from the content menu in the user info box
+    Then the list of posts of this user is empty
+    And nobody is following the user profile anymore
 
-    Scenario: Posts of blocked users are filtered from search results
-      Given "Spammy Spammer" wrote a post "Spam Spam Spam"
-      When I search for "Spam"
-      Then I should see the following posts in the select dropdown:
-        | title          |
-        | Spam Spam Spam |
-      When I block the user "Spammy Spammer"
-      And I refresh the page
-      And I search for "Spam"
-      Then the search has no results
+  Scenario: Posts of blocked users are filtered from search results
+    Given "Spammy Spammer" wrote a post "Spam Spam Spam"
+    When I search for "Spam"
+    Then I should see the following posts in the select dropdown:
+      | title          |
+      | Spam Spam Spam |
+    When I block the user "Spammy Spammer"
+    And I refresh the page
+    And I search for "Spam"
+    Then the search has no results
diff --git a/cypress/integration/user_profile/blocked-users/Content.feature b/cypress/integration/user_profile/blocked-users/Content.feature
index 8bbad7e8c..edc0d63b9 100644
--- a/cypress/integration/user_profile/blocked-users/Content.feature
+++ b/cypress/integration/user_profile/blocked-users/Content.feature
@@ -1,22 +1,22 @@
 Feature: Block a User
   As a user
   I'd like to have a button to block another user
-  To prevent him to see and interact with my contributions and also to avoid to see his/her posts
+  To prevent him from seeing and interacting with my contributions and also to avoid seeing his/her posts
 
   Background:
     Given I have a user account
     And there is an annoying user called "Spammy Spammer"
 
-   Scenario Outline: Blocked users cannot see each others posts
-     Given "Spammy Spammer" wrote a post "Spam Spam Spam"
-     And I wrote a post "I hate spammers"
-     And I block the user "Spammy Spammer"
-     When I log in with:
-       | Email | Password |
-       | <email> | <password> |
-     Then I see only one post with the title "<expected_title>"
-     Examples:
-       | email                      | password | expected_title  |
-       | peterpan@example.org       | 1234     | I hate spammers |
-       | spammy-spammer@example.org | 1234     | Spam Spam Spam  |
+  Scenario Outline: Blocked users cannot see each others posts
+    Given "Spammy Spammer" wrote a post "Spam Spam Spam"
+    And I wrote a post "I hate spammers"
+    And I block the user "Spammy Spammer"
+    When I log in with:
+      | Email   | Password   |
+      | <email> | <password> |
+    Then I see only one post with the title "<expected_title>"
+    Examples:
+      | email                      | password | expected_title  |
+      | peterpan@example.org       | 1234     | I hate spammers |
+      | spammy-spammer@example.org | 1234     | Spam Spam Spam  |
 
diff --git a/webapp/locales/en.json b/webapp/locales/en.json
index 03724e7cf..a045352db 100644
--- a/webapp/locales/en.json
+++ b/webapp/locales/en.json
@@ -199,7 +199,6 @@
         "search": "Posts of blocked people disappear from your search results.",
         "notifications": "Blocked users will no longer receive notifications if they are mentioned in your posts.",
         "closing": "This should be sufficient for now so that blocked users can no longer bother you."
-
       },
       "columns": {
         "name": "Name",
@@ -207,8 +206,8 @@
       },
       "empty": "So far, you have not blocked anybody.",
       "how-to": "You can block other users on their profile page via the content menu.",
-      "block": "Block User",
-      "unblock": "Unblock User"
+      "block": "Block user",
+      "unblock": "Unblock user"
     }
   },
   "admin": {

From a21cf5aef65a0ec76ed2330938cfa340de17ced2 Mon Sep 17 00:00:00 2001
From: Matt Rider <mattwr18@gmail.com>
Date: Wed, 14 Aug 2019 15:19:27 +0200
Subject: [PATCH 26/26] Fix cypress test

---
 .../integration/user_profile/blocked-users/Blocking.feature   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cypress/integration/user_profile/blocked-users/Blocking.feature b/cypress/integration/user_profile/blocked-users/Blocking.feature
index 07d84d7bf..9ab4fde6e 100644
--- a/cypress/integration/user_profile/blocked-users/Blocking.feature
+++ b/cypress/integration/user_profile/blocked-users/Blocking.feature
@@ -10,7 +10,7 @@ Feature: Block a User
 
   Scenario: Block a user
     Given I am on the profile page of the annoying user
-    When I click on "Block User" from the content menu in the user info box
+    When I click on "Block user" from the content menu in the user info box
     And I navigate to my "Blocked users" settings page
     Then I can see the following table:
       | Avatar | Name           |
@@ -20,7 +20,7 @@ Feature: Block a User
     Given I follow the user "Spammy Spammer"
     And "Spammy Spammer" wrote a post "Spam Spam Spam"
     When I visit the profile page of the annoying user
-    And I click on "Block User" from the content menu in the user info box
+    And I click on "Block user" from the content menu in the user info box
     Then the list of posts of this user is empty
     And nobody is following the user profile anymore