/src/test/resources/examples/RenameUserDoNotUse.groovy

package examples



import com.atlassian.core.ofbiz.association.AssociationManager

import com.atlassian.core.ofbiz.util.CoreTransactionUtil

import com.atlassian.event.api.EventPublisher

import com.atlassian.jira.ComponentManager

import com.atlassian.jira.ManagerFactory

import com.atlassian.jira.bc.filter.SearchRequestService

import com.atlassian.jira.bc.portal.PortalPageService

import com.atlassian.jira.event.ClearCacheEvent

import com.atlassian.jira.favourites.FavouritesManager

import com.atlassian.jira.imports.project.parser.UserAssociationParser

import com.atlassian.jira.issue.IssueManager

import com.atlassian.jira.issue.cache.CacheManager

import com.atlassian.jira.issue.index.IssueIndexManager

import com.atlassian.jira.issue.search.CachingSearchRequestStore

import com.atlassian.jira.issue.search.SearchRequestManager

import com.atlassian.jira.issue.search.SearchRequestStore

import com.atlassian.jira.issue.security.IssueSecuritySchemeManagerImpl

import com.atlassian.jira.notification.DefaultNotificationSchemeManager

import com.atlassian.jira.notification.type.SingleUser

import com.atlassian.jira.permission.DefaultPermissionSchemeManager

import com.atlassian.jira.portal.CachingPortalPageStore

import com.atlassian.jira.portal.PortalPageManager

import com.atlassian.jira.security.roles.CachingProjectRoleAndActorStore

import com.atlassian.jira.security.roles.actor.UserRoleActorFactory

import com.atlassian.jira.sharing.ShareManager

import com.atlassian.jira.util.ImportUtils

import com.opensymphony.user.UserManager

import org.apache.log4j.Category

import org.ofbiz.core.entity.*

import com.opensymphony.user.EntityNotFoundException

import com.atlassian.jira.util.collect.EnclosedIterable

import com.atlassian.jira.issue.search.SearchRequest

import com.atlassian.jira.util.Consumer

import com.atlassian.query.clause.ClauseVisitor

import com.atlassian.query.clause.AndClause

import com.atlassian.query.clause.NotClause

import com.atlassian.query.clause.OrClause

import com.atlassian.query.clause.TerminalClause

import com.atlassian.query.clause.Clause

import com.atlassian.jira.jql.builder.JqlQueryBuilder

import com.atlassian.jira.jql.parser.JqlQueryParser

import com.atlassian.query.operand.Operand

import com.atlassian.query.operand.OperandVisitor

import com.atlassian.query.operand.EmptyOperand

import com.atlassian.query.operand.FunctionOperand

import com.atlassian.query.operand.MultiValueOperand

import com.atlassian.query.operand.SingleValueOperand

import com.atlassian.query.clause.TerminalClauseImpl

import com.atlassian.query.Query

import com.atlassian.query.QueryImpl

import com.atlassian.jira.bc.JiraServiceContextImpl



Category log = Category.getInstance("com.onresolve.jira.groovy.Scratch")



ComponentManager componentManager = ComponentManager.getInstance()

UserManager userManager = UserManager.getInstance()

FavouritesManager favouritesManager = ComponentManager.getComponentInstanceOfType(FavouritesManager.class) as FavouritesManager

SearchRequestStore searchRequestStore = ComponentManager.getComponentInstanceOfType(SearchRequestStore.class) as SearchRequestStore

CachingSearchRequestStore cachingSearchRequestStore = ComponentManager.getComponentInstanceOfType(CachingSearchRequestStore.class) as CachingSearchRequestStore

CachingPortalPageStore cachingPortalPageStore = ComponentManager.getComponentInstanceOfType(CachingPortalPageStore.class) as CachingPortalPageStore

ShareManager shareManager = ComponentManager.getComponentInstanceOfType(ShareManager.class) as ShareManager

SearchRequestManager searchRequestManager = componentManager.getSearchRequestManager()

SearchRequestService searchRequestService = componentManager.getSearchRequestService()

IssueManager issueManager = componentManager.getIssueManager()

AssociationManager associationManager = ComponentManager.getComponentInstanceOfType(AssociationManager.class) as AssociationManager

CachingProjectRoleAndActorStore cachingProjectRoleAndActorStore = ComponentManager.getComponentInstanceOfType(CachingProjectRoleAndActorStore.class) as CachingProjectRoleAndActorStore

DefaultNotificationSchemeManager notificationSchemeManager = ComponentManager.getComponentInstanceOfType(DefaultNotificationSchemeManager.class) as DefaultNotificationSchemeManager

DefaultPermissionSchemeManager defaultPermissionSchemeManager = ComponentManager.getComponentInstanceOfType(DefaultPermissionSchemeManager.class) as DefaultPermissionSchemeManager

IssueSecuritySchemeManagerImpl securitySchemeManager = ComponentManager.getComponentInstanceOfType(IssueSecuritySchemeManagerImpl.class) as IssueSecuritySchemeManagerImpl



Set<Long> reindexIssueIds = new HashSet()



String sourceUser = 'rchapma4'

String targetUser = 'rchapma5'



DelegatorInterface gd = (DelegatorInterface) componentManager.getComponentInstanceOfType(DelegatorInterface.class)

IssueIndexManager indexManager = ComponentManager.getInstance().getIndexManager()



private def reindexIssue(IssueManager issueManager, Long issueId, Category log, IssueIndexManager indexManager) {

    GenericValue issue = issueManager.getIssue(issueId)

    boolean wasIndexing = ImportUtils.isIndexIssues();

    ImportUtils.setIndexIssues(true);

    ManagerFactory.getCacheManager().flush(CacheManager.ISSUE_CACHE, issue)

    log.debug("Reindex issue ${issue.key}")

    indexManager.reIndex(issue);

    ImportUtils.setIndexIssues(wasIndexing)

}



boolean preview = false

List msgs = []

String msg

boolean began = false



private def getLog() {

    return log

}



EnclosedIterable<SearchRequest> srs = searchRequestManager.getAll()

srs.foreach(new Consumer<SearchRequest>() {

    void consume(SearchRequest sr) {



        if (sr.name != "ReporterIsRenamedUser") {

            return

        }

        log.debug("visiting")

        Query query = sr.getQuery()

        log.debug query



        Clause whereClause = query.getWhereClause()

        Clause newWhereClause = whereClause.accept(new ClauseVisitor() {



            Object visit(AndClause andClause) {

                println("visit")

                getLog().debug("AndClause")

                andClause

            }



            Object visit(NotClause notClause) {

                getLog().debug("NotClause")

                notClause

            }



            Object visit(OrClause orClause) {

                getLog().debug("OrClause")

                orClause

            }



            Object visit(TerminalClause clause) {

                // println("visit TerminalClause")

                getLog().debug "clause.getName(): " + clause.getName()



                if (["reporter", "assignee"].contains (clause.getName())) {

                    Operand operand = clause.getOperand()

                    println operand.getDisplayString()

                    Operand newOp = operand.accept(new OperandVisitor() {

                        Object visit(EmptyOperand empty) {

                            empty

                        }



                        Object visit(FunctionOperand function) {

                            function

                        }



                        Object visit(MultiValueOperand multiValue) {

                            getLog().debug "multiValue: $multiValue"

                            multiValue

                        }



                        Object visit(SingleValueOperand singleValueOperand) {

                            getLog().debug "singleValueOperand: $singleValueOperand"

                            getLog().debug singleValueOperand.getStringValue()

                            getLog().debug "Update admin to anuser"

                            new SingleValueOperand("anuser")

                        }



                    }) as Operand

                    getLog().debug "newOp: $newOp"

                    TerminalClauseImpl newTermClause = new TerminalClauseImpl(clause.name, clause.getOperator(), newOp)

                    getLog().debug("newTermClause: " + newTermClause)

                    return newTermClause



                }



                println clause.getOperator().getDisplayString()

                clause

            }



        }) as Clause

        log.debug "total where clause: " + newWhereClause



        query.whereClause



        if (query.whereClause.toString() != newWhereClause.toString()) {

            // this is stupid but setting a queryString seems to blow away the whereClause, so we do this twice

            log.debug("Update sr name: " + sr.name)



/*

            Query newQuery = new QueryImpl(newWhereClause)

            newQuery = new QueryImpl(newWhereClause, query.orderByClause, newQuery.queryString)

            log.debug("newQuery: $newQuery")

            sr.setQuery(newQuery)

            JiraServiceContextImpl ctx = new JiraServiceContextImpl(userManager.getUser(sr.ownerUserName))

            searchRequestService.validateFilterForUpdate(ctx, sr)

            log.debug("errors: " + ctx.getErrorCollection())

            searchRequestService.updateFilter(ctx, sr)

            log.debug("errors: " + ctx.getErrorCollection())

*/

        }

        else {

            log.debug("No need to update name: " + sr.name)

        }

    }

})



return



if (! preview) {

    log.debug("Begin transaction")

    began = CoreTransactionUtil.begin();

}



try {



    try {

        userManager.getUser("def")

        sourceUser = "def"

        targetUser = "abc"

    }

    catch (EntityNotFoundException e) {

        try {

            log.debug "no user def"

            userManager.getUser("abc")

            sourceUser = "abc"

            targetUser = "def"

        }

        catch (EntityNotFoundException ef) {

            log.error("No abc or def")

            return

        }

    }



    msg = "Beginning rename of $sourceUser to $targetUser"

    log.warn(msg)

    msgs << msg



    //User user = UserUtils.createUser("abc", "x", "abc@blah.com", "Mr ABC", ["jira-users"])

    //return



    // Rename the user record itself

    List gvs = gd.findByAnd("OSUser", [name: sourceUser])

    assert gvs.size() == 1

    if (! preview) {

        GenericValue usergv = gvs.first() as GenericValue

        usergv.set("name", targetUser)

        usergv.store()

    }



    // group memberships

    gvs = gd.findByAnd("OSMembership", [userName: sourceUser])

    msg = "Update ${gvs.size()} OSMembership records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("userName", targetUser)

            gv.store()

        }

    }



    // SearchRequest ownership

    gvs = gd.findByOr("SearchRequest", [user: sourceUser, author: sourceUser])

    msg = "Update ${gvs.size()} SearchRequest records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            if (gv.get("user")) {

                gv.set("user", targetUser)

            }

            if (gv.get("author")) {

                gv.set("author", targetUser)

            }

            cachingSearchRequestStore.removeFromCache(gv.getLong("id"))

            gv.store()

        }

    }



    ["PortalPage", "ColumnLayout", "UserHistoryItem", "FilterSubscription", "FavouriteAssociations"].each {String entityName ->

        gvs = gd.findByAnd(entityName, [username: sourceUser])

        msg = "Update ${gvs.size()} $entityName records"

        log.debug(msg)

        msgs << msg

        if (!preview) {

            gvs.each {GenericValue gv ->

                gv.set("username", targetUser)

                gv.store()

            }

        }

    }

    // note: for versions prior to 4.1 the favouritesStoreCache needs to be flushed



    // Core issue fields

    gvs = gd.findByOr("Issue", [reporter: sourceUser, assignee: sourceUser])

    msg = "Update ${gvs.size()} Issue records"

    log.debug(msg)

    msgs << msg

    gvs.each {GenericValue gv ->

        if (!preview) {

            if (gv.get("reporter") == sourceUser) {

                gv.set("reporter", targetUser)

            }

            if (gv.get("assignee") == sourceUser) {

                gv.set("assignee", targetUser)

            }

            gv.store()

        }

        reindexIssueIds.add(gv.getLong("id"))

    }



    // issue transition history

    gvs = gd.findByOr("Action", [author: sourceUser, updateauthor: sourceUser])

    msg = "Update ${gvs.size()} Action records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            if (gv.get("author") == sourceUser) {

                gv.set("author", targetUser)

            }

            if (gv.get("updateauthor") == sourceUser) {

                gv.set("updateauthor", targetUser)

            }

            gv.store()

        }

    }



    // change groups

    gvs = gd.findByAnd("ChangeGroup", [author: sourceUser])

    msg = "Update ${gvs.size()} ChangeGroup records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("author", targetUser)

            gv.store()

        }

    }



    // Change items

    EntityConditionList conditionList = new EntityConditionList(

        [new EntityConditionList(

            [

                new EntityExpr("oldvalue", EntityOperator.EQUALS, sourceUser),

                new EntityExpr("newvalue", EntityOperator.EQUALS, sourceUser),

            ], EntityOperator.OR),

            new EntityConditionList([new EntityExpr("field", EntityOperator.IN, ["reporter", "assignee"])], EntityOperator.AND)

        ], EntityOperator.AND

    )

    gvs = gd.findByCondition("ChangeItem", conditionList, ["id", "field", "oldvalue", "newvalue"], Collections.<String> emptyList())

    msg = "Update ${gvs.size()} ChangeItem records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            if (gv.get("oldvalue") == sourceUser) {

                gv.set("oldvalue", targetUser)

            }

            if (gv.get("newvalue") == sourceUser) {

                gv.set("newvalue", targetUser)

            }

            gv.store()

        }

    }



    // Watchers and voters

    List userAssocCList = [

            new EntityExpr("sourceName", EntityOperator.EQUALS, sourceUser),

            new EntityExpr("associationType", EntityOperator.IN,

                [UserAssociationParser.ASSOCIATION_TYPE_WATCH_ISSUE, UserAssociationParser.ASSOCIATION_TYPE_VOTE_ISSUE]),

        ]

    gvs = gd.findByAnd("UserAssociation", userAssocCList)

    msg = "Update ${gvs.size()} UserAssociation records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gd.removeValue(gv)



            gv.set("sourceName", targetUser)

            gd.create(gv)

            // gv.store() doesn't work because we're changing the primary key

        }

    }



    // roles

    gvs = gd.findByAnd("ProjectRoleActor", [roletype: UserRoleActorFactory.TYPE, roletypeparameter: sourceUser])

    msg = "Update ${gvs.size()} ProjectRoleActor records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("roletypeparameter", targetUser)

            gv.store()

        }

        cachingProjectRoleAndActorStore.clearCaches()

    }



    // SharePermissions not required as cannot share with a user



    // worklogs

    gvs = gd.findByOr("Worklog", [author: sourceUser, updateauthor: sourceUser])

    msg = "Update ${gvs.size()} Worklog records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            if (gv.get("author") == sourceUser) {

                gv.set("author", targetUser)

            }

            if (gv.get("updateauthor") == sourceUser) {

                gv.set("updateauthor", targetUser)

            }

            gv.store()

        }

    }



    // project and comp leads

    gvs = gd.findByAnd("Project", [lead: sourceUser])

    msg = "Update ${gvs.size()} Project records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("lead", targetUser)

            gv.store()

        }

    }

    gvs = gd.findByAnd("Component", [lead: sourceUser])

    msg = "Update ${gvs.size()} Component records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("lead", targetUser)

            gv.store()

        }

    }



    // notification schemes

    gvs = gd.findByAnd("Notification", [type: SingleUser.DESC, parameter: sourceUser])

    msg = "Update ${gvs.size()} Notification records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("parameter", targetUser)

            gv.store()

        }

        notificationSchemeManager.flushProjectSchemes()

    }



    // permission schemes

    gvs = gd.findByAnd("SchemePermissions", [type: "user", parameter: sourceUser])

    msg = "Update ${gvs.size()} SchemePermissions records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("parameter", targetUser)

            gv.store()

        }

        defaultPermissionSchemeManager.flushProjectSchemes()

        defaultPermissionSchemeManager.flushSchemeEntities()

    }



    // issue security schemes

    gvs = gd.findByAnd("SchemeIssueSecurities", [type: "user", parameter: sourceUser])

    msg = "Update ${gvs.size()} SchemeIssueSecurities records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("parameter", targetUser)

            gv.store()

        }

        securitySchemeManager.flushProjectSchemes()

    }



    // user and multi-user custom fields

    gvs = gd.findByCondition("CustomField",

        new EntityExpr("customfieldtypekey", EntityOperator.IN,

            [

                "com.atlassian.jira.plugin.system.customfieldtypes:userpicker",

                "com.atlassian.jira.plugin.system.customfieldtypes:multiuserpicker"

            ])

        ,

        ["id"], Collections.<String> emptyList())

    Long cfValueKount = 0

    gvs.each {GenericValue gv ->

        gv.getRelatedByAnd("ChildCustomFieldValue", [stringvalue: sourceUser]).each {GenericValue cfGv ->

            cfValueKount++

            if (!preview) {

                cfGv.set("stringvalue", targetUser)

                cfGv.store()

            }

            reindexIssueIds.add(cfGv.getLong("issue"))

        }

    }

    msg = "Update ${gvs.size()} CustomFieldValue records" // not strictly true

    log.debug(msg)

    msgs << msg



    // possibly todo: update search parameters that refer to user custom fields

    // make sure they're not logged on?



    // todo: OS_CURRENTSTEP owner, caller, OS_HISTORYSTEP, jiraworkflows



    // fileattachments

    gvs = gd.findByAnd("FileAttachment", [author: sourceUser])

    msg = "Update ${gvs.size()} FileAttachment records"

    log.debug(msg)

    msgs << msg

    if (!preview) {

        gvs.each {GenericValue gv ->

            gv.set("author", targetUser)

            gv.store()

        }

    }



    // -------------------------------------- Finalise --------------------------------------

    if (! preview) {

        log.debug("Commit transaction")

        CoreTransactionUtil.commit(began);



        // Only for 4.1 and above - clearing the other caches are not necessary above but kept there if

        // I decide to backport this

        log.debug("Publish clear cache event")

        ComponentManager.getComponentInstanceOfType(EventPublisher.class).publish(ClearCacheEvent.INSTANCE);



        // reindex issues

        reindexIssueIds.each {Long issueId ->

            reindexIssue(issueManager, issueId, log, indexManager);

        }



        UserManager.getInstance().flushCaches()

        user = userManager.getUser(targetUser)

        user.getAccessProvider().flushCaches()

        user.getProfileProvider().flushCaches()

    }



    msg = "Reindex ${reindexIssueIds.size()} issues"

    log.debug(msg)

    msgs << msg

}

catch (Exception e) {

    log.error("Problem renaming user, rolling back")

    CoreTransactionUtil.rollback(began)

}

finally {

    // not sure if we need anything here

}



msgs.join("\n")