Question

Really my question is “Can the code sample below be even smaller? Basically the code sample is designed to first look through a list of objects, find the most granular (in this case it is branch) and then query backwards depending on what object it finds.

1 – If it finds a branch, return the findAllBy against the branch

2 – If it finds a department, return the findAllBy against the department

3 – If it finds an organization, return the findAllBy against the organization

The goal is to find the most granular object (which is why order is important), but do I need to have two separate blocks (one to define the objects, the other to check if they exist)? Or can those two executions be made into one command…

def resp
def srt = [sort:"name", order:"asc"]

def branch = listObjects.find{it instanceof Branch} 
def department = listObjects.find{it instanceof Department}
def organization = listObjects.find{it instanceof Organization}

resp = !resp && branch ? Employees.findAllByBranch(branch,srt) : resp
resp = !resp && department ? Employees.findAllByDepartment(department,srt) : resp
resp = !resp && organization ? Employees.findAllByOrganization(organization,srt) : resp

return resp

What I’m thinking is something along the lines of this:

def resp
resp = Employees.findAllByBranch(listObjects.find{it instanceof Branch})
resp = !resp ? Employees.findAllByDepartment(listObjects.find{it instanceof Department}) : resp
resp = !resp ? Employees.findAllByOrganization(listObjects.find{it instanceof Organization}) : resp

But I believe that will throw an exception since those objects might be null

Answer 1

You can shorten it up a bit more with findResult instead of a for in loop with a variable you need to def outside:

def listObjects // = some predetermined list that you've apparently created
def srt = [sort:"name", order:"asc"]

def result = [Branch, Department, Organization].findResult { clazz -> 
    listObjects?.find { it.class.isAssignableFrom(clazz) }?.with { foundObj ->
        Employees."findAllBy${clazz.name}"(foundObj, srt)
    }
}

findResult is similar to find, but it returns the result from the first non-null item rather than the item itself. It avoids the need for a separate collection variable outside of the loop.

Edit: what I had previously didn’t quite match the behavior that I think you were looking for (I don’t think the other answers do either, but I could be misunderstanding). You have to ensure that there’s something found in the list before doing the findAllBy or else you could pull back null items which is not what you’re looking for.

In real, production code, I’d actually do things a bit differently though. I’d leverage the JVM type system to only have to spin through the listObjects once and short circuit when it found the first Branch/Department/Organization like this:

def listObjects
def sort = [sort:"name", order:"asc"]

def result = listObjects?.findResult { findEmployeesFor(it, sort) }

...  // then have these methods to actually exercise the type specific findEmployeesFor

def findEmployeesFor(Branch branch, sort) { Employees.findAllByBranch(branch, sort) }
def findEmployeesFor(Department department, sort { Employees.findAllByDepartment(department, sort)}
def findEmployeesFor(Organization organization, sort { Employees.findAllByOrganization(organization, sort)}
def findEmployeesFor(Object obj, sort) { return null } // if listObjects can hold non/branch/department/organization objects

I think that this code is actually clearer and it reduces the number of times we iterate over the list and the number of reflection calls we need to make.