public void runTool()

in stack/tools/src/main/java/org/apache/usergrid/tools/RemoveAdminUserFromOrg.java [63:219]


    public void runTool( CommandLine line ) throws Exception {

        startSpring();

        String orgName = line.getOptionValue("org");
        String email = line.getOptionValue("user");

        if ( orgName == null ) {
            System.out.println("org argument is required");
        }

        if ( email == null ) {
            System.out.println("user argument is required");
        }

        boolean remove = line.hasOption( "remove" );

        // get user and org objects

        UUID ownerId = emf.getManagementAppId();
        CpEntityManager em = (CpEntityManager)emf.getEntityManager( ownerId );

        UserInfo userInfo = managementService.getAdminUserByEmail( email );
        User user = em.get( userInfo.getUuid(), User.class );

        OrganizationInfo orgInfo = managementService.getOrganizationByName( orgName );
        Group group = em.get( orgInfo.getUuid(), Group.class );


        StringBuilder sb = new StringBuilder();
        try {

            sb.append( "\nUser " ).append( user.getUsername() ).append( ":" ).append( user.getUuid().toString() );
            sb.append( "\nOrganization " ).append( orgName ).append( ":" ).append( orgInfo.getUuid() );


            //---------------------------------------------------------------------------------------------
            // log connections found via entity manager and management service

            Results users = em.getCollection( group, "users", null, 1000, Query.Level.ALL_PROPERTIES, false );
            if ( users.isEmpty() ) {
                sb.append("\n   Organization has no Users\n");
            } else {
                sb.append("\n   Organization has Users:\n");
                for ( Entity entity : users.getEntities() ) {
                    sb.append("      User ").append( entity.getUuid() ).append( ":" ).append( entity.getName());
                    sb.append("\n" );
                }
            }

            BiMap<UUID, String> orgsForAdminUser = managementService.getOrganizationsForAdminUser( user.getUuid() );
            if (orgsForAdminUser.isEmpty()) {
                sb.append( "   User has no Organizations\n" );
            } else {
                sb.append( "   User has Organizations\n" );
                for (UUID key : orgsForAdminUser.keySet()) {
                    String name = orgsForAdminUser.get( key );
                    sb.append( "       Organization " ).append( name ).append( ":" ).append( key ).append( "\n" );
                }
            }


            List<UserInfo> adminUsers = managementService.getAdminUsersForOrganization( orgInfo.getUuid() );
            if (adminUsers.isEmpty()) {
                sb.append( "   Organization has no Admin Users\n" );
            } else {
                sb.append( "   Organization has Admin Users:" ).append( "\n" );
                for (UserInfo info : adminUsers) {
                    sb.append( "       Admin User " )
                        .append( info.getUsername() ).append( ":" ).append( info.getUuid() ).append( "\n" );
                }
            }


            //---------------------------------------------------------------------------------------------
            // log connections found via graph manager

            final GraphManagerFactory gmf = injector.getInstance( GraphManagerFactory.class );
            final GraphManager graphManager = gmf.createEdgeManager(
                new ApplicationScopeImpl( new SimpleId( emf.getManagementAppId(), Application.ENTITY_TYPE ) ) );

            final Id groupId = new SimpleId( orgInfo.getUuid(), Group.ENTITY_TYPE );
            final Id userId = new SimpleId( user.getUuid(), User.ENTITY_TYPE );


            // edge versions from group -> user

            sb.append( "Edges from collectionToEntity:\n" );
            SearchByEdge collectionToEntity = CpNamingUtils.createEdgeFromCollectionName(
                groupId, "users", userId );

            graphManager.loadEdgeVersions( collectionToEntity ).forEach( edge ->
                sb.append( "edge from " ).append( edge.getSourceNode() )
                  .append( " to " ).append( edge.getTargetNode()));
            sb.append("\n" );

            // edge versions from user -> group

            sb.append( "Edges from entityToCollection:\n" );
            SearchByEdge entityToCollection = CpNamingUtils.createEdgeFromCollectionName(
                userId, "groups", groupId );

            graphManager.loadEdgeVersions( entityToCollection ).forEach( edge ->
                sb.append( "edge from " ).append( edge.getSourceNode() )
                    .append( " to " )
                    .append( edge.getTargetNode() ).append("\n") );


            //---------------------------------------------------------------------------------------------
            // optionally remove admin user

            if ( remove ) {
                // use normal means to remove user from org
                managementService.removeAdminUserFromOrganization( user.getUuid(), orgInfo.getUuid() );
            }

            // make sure no edges left behind

            String usersCollType     = CpNamingUtils.getEdgeTypeFromCollectionName( "users" );
            sb.append( "Edges of type ").append( usersCollType ).append(" targeting user:\n" );

            graphManager.loadEdgesToTarget( createSearch( userId, usersCollType ) ).forEach( edge -> {

                if ( remove && edge.getSourceNode().getUuid().equals( group.getUuid() ) ) {
                    sb.append( "    DELETING edge from " ).append( edge.getSourceNode() )
                        .append( " to " ).append( edge.getTargetNode() ).append("\n");

                    graphManager.markEdge( edge );
                    graphManager.deleteEdge( edge );

                } else {
                    sb.append( "    edge from " ).append( edge.getSourceNode() )
                        .append( " to " ).append( edge.getTargetNode() ).append("\n");
                }
            });

            sb.append( "Edges of type ").append( usersCollType ).append(" sourced from group:\n" );

            graphManager.loadEdgesFromSource( createSearch( groupId, usersCollType ) ).forEach( edge -> {

                if ( remove && edge.getTargetNode().getUuid().equals( user.getUuid() ) ) {
                    sb.append( "    DELETING edge from " ).append( edge.getSourceNode() )
                        .append( " to " ).append( edge.getTargetNode() ).append("\n");

                    graphManager.markEdge( edge ).toBlocking().lastOrDefault( null );
                    graphManager.deleteEdge( edge ).toBlocking().lastOrDefault( null );

                } else {
                    sb.append( "    edge from " ).append( edge.getSourceNode() )
                        .append( " to " ).append( edge.getTargetNode() ).append("\n");
                }}
            );

        } finally {
            logger.info( sb.toString() );
        }
    }