Adding button for admins to take over a workspace they follow or is public

This was squashed from commits in #290

Author: srbd

backend/app/controllers/api/Workspaces.scala

@@ -45,6 +45,11 @@ object UpdateWorkspaceName {
   implicit val format = Json.format[UpdateWorkspaceName]
 }
 
+case class UpdateWorkspaceOwner(owner: String)
+object UpdateWorkspaceOwner {
+  implicit val format = Json.format[UpdateWorkspaceOwner]
+}
+
 case class AddItemParameters(uri: Option[String], size: Option[Long], mimeType: Option[String])
 object AddItemParameters {
   implicit val format = Json.format[AddItemParameters]
@@ -199,6 +204,21 @@ class Workspaces(
     }
   }
 
+  def updateWorkspaceOwner(workspaceId: String) = ApiAction.attempt(parse.json) { req =>
+    for {
+      data <- req.body.validate[UpdateWorkspaceOwner].toAttempt
+
+      _ = logAction(req.user, workspaceId, s"Updating workspace owner. Data: $data")
+      _ <- annotation.updateWorkspaceOwner(
+        req.user.username,
+        workspaceId,
+        data.owner
+      )
+    } yield {
+      NoContent
+    }
+  }
+
   def deleteWorkspace(workspaceId: String) = ApiAction.attempt { req: UserIdentityRequest[_] =>
     logAction(req.user, workspaceId, s"Delete workspace. ID: $workspaceId")
 

backend/app/model/annotations/Workspace.scala

@@ -142,6 +142,7 @@ case class WorkspaceMetadata(id: String,
                              name: String,
                              isPublic: Boolean,
                              tagColor: String,
+                             creator: PartialUser,
                              owner: PartialUser,
                              followers: List[PartialUser]
 )
@@ -150,12 +151,13 @@ object WorkspaceMetadata {
   implicit val write: Writes[WorkspaceMetadata] = Json.writes[WorkspaceMetadata]
   implicit val read: Reads[WorkspaceMetadata] = Json.reads[WorkspaceMetadata]
 
-  def fromNeo4jValue(v: Value, owner: DBUser, followers: List[DBUser]): WorkspaceMetadata = {
+  def fromNeo4jValue(v: Value, creator: DBUser, owner:DBUser, followers: List[DBUser]): WorkspaceMetadata = {
     WorkspaceMetadata(
       v.get("id").asString(),
       v.get("name").asString(),
       v.get("isPublic").asBoolean(),
       v.get("tagColor").asString(),
+      creator.toPartial,
       owner.toPartial,
       followers.map(_.toPartial)
     )
@@ -166,6 +168,7 @@ case class Workspace(id: String,
                      name: String,
                      isPublic: Boolean,
                      tagColor: String,
+                     creator: PartialUser,
                      owner: PartialUser,
                      followers: List[PartialUser],
                      rootNode: TreeEntry[WorkspaceEntry])
@@ -180,6 +183,7 @@ object Workspace {
       name = metadata.name,
       isPublic = metadata.isPublic,
       tagColor = metadata.tagColor,
+      creator = metadata.creator,
       owner = metadata.owner,
       followers = metadata.followers,
       rootNode = rootNode

backend/app/services/annotations/Annotations.scala

@@ -17,6 +17,7 @@ trait Annotations {
   def getWorkspaceContents(currentUser: String, id: String): Attempt[TreeEntry[WorkspaceEntry]]
   def insertWorkspace(username: String, id: String, name: String, isPublic: Boolean, tagColor: String): Attempt[Unit]
   def updateWorkspaceName(currentUser: String, id: String, name: String): Attempt[Unit]
+  def updateWorkspaceOwner(currentUser: String, id: String, owner: String): Attempt[Unit]
   def updateWorkspaceIsPublic(currentUser: String, id: String, isPublic: Boolean): Attempt[Unit]
   def updateWorkspaceFollowers(currentUser: String, id: String, followers: List[String]): Attempt[Unit]
   def deleteWorkspace(currentUser: String, workspace: String): Attempt[Unit]

backend/app/services/annotations/Neo4jAnnotations.scala

@@ -48,9 +48,10 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
     tx.run(
       """
         |MATCH (workspace :Workspace)
-        |WHERE (:User { username: {currentUser} })-[:FOLLOWING|:CREATED]->(workspace) OR workspace.isPublic
+        |WHERE (:User { username: {currentUser} })-[:FOLLOWING|:OWNS]->(workspace) OR workspace.isPublic
         |MATCH (creator :User)-[:CREATED]->(workspace)<-[:FOLLOWING]-(follower :User)
-        |RETURN workspace, creator, collect(distinct follower) as followers
+        |MATCH (owner :User)-[:OWNS]->(workspace)
+        |RETURN workspace, creator, owner, collect(distinct follower) as followers
       """.stripMargin,
       parameters(
         "currentUser", currentUser
@@ -59,9 +60,10 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
       summary.list().asScala.toList.map { r =>
         val workspace = r.get("workspace")
         val creator = DBUser.fromNeo4jValue(r.get("creator"))
+        val owner = DBUser.fromNeo4jValue(r.get("owner"))
         val followers = r.get("followers").asList[DBUser](DBUser.fromNeo4jValue(_)).asScala.toList
 
-        WorkspaceMetadata.fromNeo4jValue(workspace, creator, followers)
+        WorkspaceMetadata.fromNeo4jValue(workspace, creator, owner, followers)
       }
     }
   }
@@ -70,9 +72,10 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
     tx.run(
       """
         |MATCH (workspace :Workspace {id: {id} })
-        |WHERE (:User { username: {currentUser} })-[:FOLLOWING|:CREATED]->(workspace) OR workspace.isPublic
+        |WHERE (:User { username: {currentUser} })-[:FOLLOWING|:OWNS]->(workspace) OR workspace.isPublic
         |MATCH (creator :User)-[:CREATED]->(workspace)<-[:FOLLOWING]-(follower :User)
-        |RETURN workspace, creator, collect(distinct follower) as followers
+        |MATCH (owner :User)-[:OWNS]->(workspace)
+        |RETURN workspace, creator, owner, collect(distinct follower) as followers
       """.stripMargin,
       parameters(
         "currentUser", currentUser,
@@ -85,9 +88,10 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
       ).map { r =>
         val workspace = r.head.get("workspace")
         val creator = DBUser.fromNeo4jValue(r.head.get("creator"))
+        val owner = DBUser.fromNeo4jValue(r.head.get("owner"))
         val followers = r.head.get("followers").asList[DBUser](DBUser.fromNeo4jValue(_)).asScala.toList
 
-        WorkspaceMetadata.fromNeo4jValue(workspace, creator, followers)
+        WorkspaceMetadata.fromNeo4jValue(workspace, creator, owner, followers)
       }
     }
   }
@@ -96,9 +100,10 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
     tx.run(
       """
         |MATCH (workspace: Workspace { id: {id} })
-        |WHERE (:User { username: {currentUser} })-[:FOLLOWING|:CREATED]->(workspace) OR workspace.isPublic
+        |WHERE (:User { username: {currentUser} })-[:FOLLOWING|:OWNS]->(workspace) OR workspace.isPublic
         |
         |OPTIONAL MATCH (workspace)<-[:PART_OF]-(node :WorkspaceNode)<-[:CREATED]-(nodeCreator :User)
+        |
         |OPTIONAL MATCH (node)-[:PARENT]->(parentNode :WorkspaceNode)
         |
         |OPTIONAL MATCH (:Resource {uri: node.uri})<-[todo:TODO|:PROCESSING_EXTERNALLY]-(:Extractor)
@@ -147,6 +152,7 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
         |CREATE (w: Workspace {id: {id}, name: {name}, isPublic: {isPublic}, tagColor: {tagColor}})
         |CREATE (w)<-[:CREATED]-(u)
         |CREATE (w)<-[:FOLLOWING]-(u)
+        |CREATE (w)<-[:OWNS]-(u)
         |
         |CREATE (u)-[:CREATED]->(f: WorkspaceNode {id: {rootFolderId}, name: {name}, type: 'folder'})-[:PART_OF]->(w)
         |
@@ -170,10 +176,10 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
   override def updateWorkspaceFollowers(currentUser: String, id: String, followers: List[String]): Attempt[Unit] = attemptTransaction { tx =>
     tx.run(
       """
-        |MATCH (workspace :Workspace {id: {workspaceId}})<-[:CREATED]-(creator :User {username: {username}})
+        |MATCH (workspace :Workspace {id: {workspaceId}})<-[:OWNS]-(owner :User {username: {username}})
         |
         |OPTIONAL MATCH (existingFollower :User)-[existingFollow :FOLLOWING]->(workspace)
-        |  WHERE existingFollower.username <> creator.username
+        |  WHERE existingFollower.username <> owner.username
         |
         |OPTIONAL MATCH (newFollower :User)
         |  WHERE newFollower.username IN {followers}
@@ -201,7 +207,7 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
   override def updateWorkspaceIsPublic(currentUser: String, id: String, isPublic: Boolean): Attempt[Unit] = attemptTransaction { tx =>
     tx.run(
       """
-        |MATCH (workspace :Workspace {id: {workspaceId}})<-[:CREATED]-(creator :User {username: {username}})
+        |MATCH (workspace :Workspace {id: {workspaceId}})<-[:OWNS]-(owner :User {username: {username}})
         |
         |SET workspace.isPublic = {isPublic}
         |
@@ -222,7 +228,7 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
   override def updateWorkspaceName(currentUser: String, id: String, name: String): Attempt[Unit] = attemptTransaction { tx =>
     tx.run(
       """
-        |MATCH (rootNode :WorkspaceNode)-[:PART_OF]->(workspace :Workspace {id: {workspaceId}})<-[:CREATED]-(creator :User {username: {username}})
+        |MATCH (rootNode :WorkspaceNode)-[:PART_OF]->(workspace :Workspace {id: {workspaceId}})<-[:OWNS]-(owner :User {username: {username}})
         |   WHERE NOT exists((rootNode)-[:PARENT]->(:WorkspaceNode))
         |
         |SET workspace.name = {name}
@@ -241,11 +247,36 @@ class Neo4jAnnotations(driver: Driver, executionContext: ExecutionContext, query
     }
   }
 
+  override def updateWorkspaceOwner(currentUser: String, id: String, owner: String): Attempt[Unit] = attemptTransaction { tx =>
+    val query = """
+                  MATCH (user: User { username: {username}})
+                  |MATCH (newOwner: User { username: {owner}})
+                  |MATCH (workspace: Workspace {id:{workspaceId}} )<-[ownsRelationship:OWNS]-(currentOwner:User)
+                  |WHERE (:Permission {name: "CanPerformAdminOperations"})<-[:HAS_PERMISSION]-(user)
+                  |CREATE (workspace)<-[:FOLLOWING]-(newOwner)
+                  |CREATE (workspace)<-[:OWNS]-(newOwner)
+                  |DELETE ownsRelationship
+      """.stripMargin
+    tx.run(
+      query,
+      parameters(
+        "workspaceId", id,
+        "owner", owner,
+        "username", currentUser
+      )
+    ).flatMap {
+      case r if r.summary().counters().relationshipsCreated() != 2 =>
+        Attempt.Left(IllegalStateFailure(s"Error when updating workspace owner, unexpected properties set ${r.summary().counters().propertiesSet()}"))
+      case _ =>
+        Attempt.Right(())
+    }
+  }
+
   override def deleteWorkspace(currentUser: String, workspace: String): Attempt[Unit] = attemptTransaction { tx =>
     tx.run(
       """
         |MATCH (user: User { username: {username} })
-        |MATCH (workspace: Workspace {id: {workspaceId}})<-[:CREATED]-(u:User)
+        |MATCH (workspace: Workspace {id: {workspaceId}})<-[:OWNS]-(u:User)
         |WHERE u.username = {username} OR (workspace.isPublic and (:Permission {name: "CanPerformAdminOperations"})<-[:HAS_PERMISSION]-(user))
         |MATCH (workspace)<-[:PART_OF]-(node: WorkspaceNode)
         |

backend/app/services/manifest/Neo4jManifest.scala

@@ -100,6 +100,7 @@ class Neo4jManifest(driver: Driver, executionContext: ExecutionContext, queryLog
       """
         |MATCH (w:WorkspaceNode {uri: {uri}})-[:PART_OF]->(workspace:Workspace)
         |MATCH (creator :User)-[:CREATED]->(workspace)<-[:FOLLOWING]-(follower :User)
+        |MATCH (owner :User)-[:OWNS]->(workspace)
         |return  workspace, creator, collect(distinct follower) as followers
         |""".stripMargin,
       parameters(
@@ -108,9 +109,10 @@ class Neo4jManifest(driver: Driver, executionContext: ExecutionContext, queryLog
         summary.list().asScala.toList.map { r =>
           val workspace = r.get("workspace")
           val creator = DBUser.fromNeo4jValue(r.get("creator"))
+          val owner = DBUser.fromNeo4jValue(r.get("owner"))
           val followers = r.get("followers").asList[DBUser](DBUser.fromNeo4jValue(_)).asScala.toList
 
-          WorkspaceMetadata.fromNeo4jValue(workspace, creator, followers)
+          WorkspaceMetadata.fromNeo4jValue(workspace, creator, owner, followers)
         }
     }
   }

backend/conf/routes

@@ -61,7 +61,8 @@ PUT           /api/workspaces/:workspaceId/followers                        cont
 PUT           /api/workspaces/:workspaceId/isPublic                         controllers.api.Workspaces.updateWorkspaceIsPublic(workspaceId: String)
 PUT           /api/workspaces/:workspaceId/name                             controllers.api.Workspaces.updateWorkspaceName(workspaceId: String)
 GET           /api/workspaces/:workspaceId                                  controllers.api.Workspaces.get(workspaceId: String)
-GET           /api/workspaces/:workspaceId/nodes                            controllers.api.Workspaces.getContents(workspaceId: String)
+GET           /api/workspaces/:workspaceId/nodes                           controllers.api.Workspaces.getContents(workspaceId: String)
+PUT           /api/workspaces/:workspaceId/owner                            controllers.api.Workspaces.updateWorkspaceOwner(workspaceId: String)
 POST          /api/workspaces/:workspaceId/reprocess                        controllers.api.Workspaces.reprocess(workspaceId: String, rerunSuccessful: Option[Boolean], rerunFailed: Option[Boolean])
 POST          /api/workspaces/:workspaceId/nodes                            controllers.api.Workspaces.addItemToWorkspace(workspaceId: String)
 POST          /api/workspaces/:workspaceId/remoteUrl                        controllers.api.Workspaces.addRemoteUrlToWorkspace(workspaceId: String)

backend/test/test/TestAnnotations.scala

@@ -10,7 +10,7 @@ import utils.attempt.{Attempt, Failure, UnsupportedOperationFailure}
 class TestAnnotations(usersToWorkspaces: Map[String, List[String]] = Map.empty) extends Annotations {
   override def getAllWorkspacesMetadata(currentUser: String): Attempt[List[WorkspaceMetadata]] = {
     val workspaces = usersToWorkspaces.getOrElse(currentUser, List.empty).map { id =>
-      WorkspaceMetadata(id, id, isPublic = false, "", null, List.empty)
+      WorkspaceMetadata(id, id, isPublic = false, tagColor="", creator=null, owner=null, followers=List.empty)
     }
 
     Attempt.Right(workspaces)
@@ -21,6 +21,7 @@ class TestAnnotations(usersToWorkspaces: Map[String, List[String]] = Map.empty)
   override def updateWorkspaceFollowers(currentUser: String, id: String, followers: List[String]): Attempt[Unit] = Attempt.Left(UnsupportedOperationFailure(""))
   override def updateWorkspaceIsPublic(currentUser: String, id: String, isPublic: Boolean): Attempt[Unit] = Attempt.Left(UnsupportedOperationFailure(""))
   override def updateWorkspaceName(currentUser: String, id: String, name: String): Attempt[Unit] = Attempt.Left(UnsupportedOperationFailure(""))
+  override def updateWorkspaceOwner(currentUser: String, id: String, owner: String): Attempt[Unit] = Attempt.Left(UnsupportedOperationFailure(""))
   override def deleteWorkspace(currentUser: String, workspace: String): Attempt[Unit] = Attempt.Left(UnsupportedOperationFailure(""))
   override def addFolder(currentUser: String, workspaceId: String, parentFolderId: String, folderName: String): Attempt[String] = Attempt.Left(UnsupportedOperationFailure(""))
   override def addResourceToWorkspaceFolder(currentUser: String, fileName: String, uri: Uri, size: Option[Long], mimeType: Option[String], icon: String, workspaceId: String, folderId: String, nodeId: String): Attempt[String] = Attempt.Left(UnsupportedOperationFailure(""))

backend/test/test/integration/Helpers.scala

@@ -371,6 +371,11 @@ object Helpers extends Matchers with Logging with OptionValues with Inside {
       .apply(FakeRequest().withBody(Json.toJson(UpdateWorkspaceName(name))))
   }
 
+  def setWorkspaceOwner(workspaceId: String, owner: String)(implicit timeout: Timeout, controllers: Controllers): Future[Result] = {
+    controllers.workspace.updateWorkspaceOwner(workspaceId)
+      .apply(FakeRequest().withBody(Json.toJson(UpdateWorkspaceOwner(owner))))
+  }
+
   def getFilters()(implicit controllers: Controllers, timeout: Timeout): List[Filter] = {
     contentAsJson(controllers.filters.getFilters().apply(FakeRequest())).as[List[Filter]]
   }

frontend/src/js/actions/workspaces/takeOwnershipOfWorkspace.ts

@@ -0,0 +1,33 @@
+import { updateWorkspaceOwner } from '../../services/WorkspaceApi';
+import { getWorkspacesMetadata } from './getWorkspacesMetadata';
+import { ThunkAction } from 'redux-thunk';
+import { AppAction, AppActionType, WorkspacesAction } from '../../types/redux/GiantActions';
+import { GiantState } from '../../types/redux/GiantState';
+import { getWorkspace } from './getWorkspace';
+
+export function takeOwnershipOfWorkspace(
+    id: string,
+    user: string,
+): ThunkAction<void, GiantState, null, WorkspacesAction | AppAction> {
+    return dispatch => {
+        return updateWorkspaceOwner(id, user)
+            .then(res => {
+                dispatch(getWorkspacesMetadata());
+                // We need to fire off this second call because "created by"/"owned by" labels as
+                // displayed in the "current workspace" view is accessed from the currentWorkspace state,
+                // so we need to refresh it. It's also in the workspacesMetadata state, but we don't want to
+                // search through that array to find the current workspace: currentWorkspace should always
+                // be the canonical source of info for that.
+                dispatch(getWorkspace(id));
+            })
+            .catch(error => dispatch(errorUpdatingWorkspaceMetadata(error)));
+    };
+}
+
+function errorUpdatingWorkspaceMetadata(error: Error): AppAction {
+    return {
+        type:        AppActionType.APP_SHOW_ERROR,
+        message:     'Failed to take ownership of workspace',
+        error:       error,
+    };
+}

frontend/src/js/components/workspace/TakeOwnershipOfWorkspaceModal.tsx

@@ -0,0 +1,72 @@
+import React, { useState } from 'react';
+import Modal from '../UtilComponents/Modal';
+import MdSupervisorAccount from "react-icons/lib/md/supervisor-account";
+import { Workspace } from '../../types/Workspaces';
+import { PartialUser } from '../../types/User';
+import {takeOwnershipOfWorkspace} from "../../actions/workspaces/takeOwnershipOfWorkspace";
+
+type Props = {
+    workspace: Workspace,
+    isAdmin: Boolean,
+    currentUser: PartialUser,
+    takeOwnershipOfWorkspace: typeof takeOwnershipOfWorkspace
+}
+
+export default function TakeOwnershipOfWorkspaceModal(props: Props) {
+    const [open, setOpen] = useState(false);
+
+    function onSubmit(e?: React.FormEvent) {
+        if (e) {
+            e.preventDefault();
+        }
+
+        if (props.isAdmin) {
+            props.takeOwnershipOfWorkspace(props.workspace.id, props.currentUser.username)
+        }
+        onDismiss();
+    }
+
+    function onDismiss() {
+        setOpen(false);
+    }
+
+    if (props.currentUser.username === props.workspace.owner.username)
+        return null
+    if (!props.isAdmin)
+        return null
+
+    return <React.Fragment>
+
+        {/* The component that triggers the modal (pass-through rendering of children) */}
+        <button
+            className='btn workspace__button'
+            onClick={() => setOpen(true)}
+			title='Take ownership'
+        >
+            <MdSupervisorAccount /> Take Ownership
+        </button>
+
+        <Modal isOpen={open} dismiss={onDismiss} panelClassName="modal-action__panel">
+            <form onSubmit={onSubmit}>
+                <div className='modal-action__modal'>
+                    <h2>Take over workspace {props.workspace.name}</h2>
+                    <div className='modal-action__buttons'>
+                        <button
+                            className='btn'
+                            onClick={onSubmit}
+                            autoFocus={false}
+                        >
+                            Take Ownership
+                        </button>
+                        <button
+                            className='btn'
+                            onClick={onDismiss}
+                        >
+                            Cancel
+                        </button>
+                    </div>
+                </div>
+            </form>
+        </Modal>
+    </React.Fragment>;
+}