How to reduce cyclomatic complexity of this java method

I have the next java implementation, but it has a SonarQube issue and i don't know how to reduce the method.

if (user.getUserId() != null && user.getEmail() != null
    && user.getName() != null) {
	return 1;
} else if (user.getUserId() != null && user.getEmail() != null) {
	return 2;
} else if (user.getUserId() != null && user.getName() != null) {
	return 3;
} else if (user.getUserId() != null) {
	return 4;
} else if (user.getEmail() != null && user.getName() != null) {
	return 5;
} else if (user.getName() != null) {
	return 6;
} else if (user.getEmail() != null) {
	return 7;
} else {
  return 0;
}

when the user is a Pojo of Users

class Users {

String userId;

String email;

String name;

	//getters and setters...
}

This is the real code and issue in SonarQube:

what about Pattern of Chain of Responsibility.

public abstract class Handler {

    protected Handler next;

    public abstract Integer process(User user);
}

  Handler checkIdEmailName = new Handler() {
      @Override
      public Integer process(User user) {
          boolean check = false;
          if (check) {
              return 1;
          }else {
              return next.process(user);
          }
      }
  };
  Handler checkIdEmail = new Handler() {
      @Override
      public Integer process(User user) {
          boolean check = false;
          if (check) {
              return 1;
          }else {
              return next.process(user);
          }
      }
  };
  checkIdEmailName.next = checkIdEmail;

  Integer result = checkIdEmailName.process(new User());

Break it to another methods would reduce the complexity of the method itself.
Something like

if (user.getUserId() != null && user.getEmail() != null
    && user.getName() != null) {
    return 1;
} else if (user.getUserId() != null && user.getEmail() != null) {
    return 2;
} else if (user.getUserId() != null && user.getName() != null) {
    return 3;
} else if (user.getUserId() != null) {
    return 4;
} else {
    return yourNewMethod();
}

private int yourNewMethod(User user) {
    if (user.getEmail() != null && user.getName() != null) {
        return 5;
    } else if (user.getName() != null) {
        return 6;
    } else if (user.getEmail() != null) {
        return 7;
    } else {
        return 0;
    }
}

so first of all we should emphasis what cognitive complexity is all about, and how it would make sense to reduce it. Mainly by extracting things which belongs together.

When taking a look at your method with the first 4 conditions, they share a similarity, and it is the check for userId. This means you can easily combine the checks below into one branch. Which will be easier to grasp, and also offers a nice way for extraction

if (user.getUserId() != null) {
    if (user.getEmail() != null
        && user.getName() != null) {
        return 1;
    } else if (user.getEmail() != null) {
        return 2;
    } else if (user.getName() != null) {
        return 3;
    } else {
        return 4;
    }
} else if (user.getEmail() != null && user.getName() != null) {
    return 5;
} else if (user.getName() != null) {
    return 6;
} else if (user.getEmail() != null) {
    return 7;
} else {
    return 0;
}

Based on this you can further extract easily like

if (user.getUserId() != null) {
    return fancyNameForAdditionalUserIdChecks(user);
} else if (user.getEmail() != null && user.getName() != null) {
    return 5;
} else if (user.getName() != null) {
    return 6;
} else if (user.getEmail() != null) {
    return 7;
} else {
    return 0;
}

private int fancyNameForAdditionalUserIdChecks(Users user) {
    if (user.getEmail() != null
        && user.getName() != null) {
        return 1;
    } else if (user.getEmail() != null) {
        return 2;
    } else if (user.getName() != null) {
        return 3;
    } else {
        return 4;
    }
}

Now we only have four main branches in the first if - a developer who does not care about cases where the userid is null, can simple skip it, and he will not need to process all those branches. Where as if needs to, he has only one condition to first check, and the rest is easier to grasp.

To handle such a case, you always should think about, how somebody is reading code. What benefit he gets, and were you can reduce the cognitive load so it will gets easier for the following developer to understand. Machines will never have problem reading our code, but writing code which is easy to read by humans, that is the hard part.

Sidenote:
i would rather rework your Dao methods, and in this case put that logic into the dao, by providing a map of paramaters to the dao, and let the dao handle such a logic. like dao.find(Map<String, Object> params) and you could handle this based on the fields available or not available.

Here is the reduce complexity code,

    boolean userIdAvailable = user.getUserId() != null;
boolean emailAvailable = user.getEmail() != null;
boolean nameAvailable = user.getName();
short response = checkAll(userIdAvailable, emailAvailable, nameAvailable);
if (response == 0) {
response = checkEmailAndName(emailAvailable, nameAvailable);
if (response == 0) {
checkUserIdAndName(userIdAvailable, nameAvailable);
}
}
short checkAll(boolean userIdAvailable, boolean emailAvailable, boolean nameAvailable) {
return userIdAvailable && emailAvailable && nameAvailable ? 1 : 0;
}
short checkEach(boolean userIdAvailable, boolean emailAvailable, boolean nameAvailable) {
short response = 0;
if(userIdAvailable) {
response = 4;
} else if(emailAvailable) {
response = 7;
} else if(nameAvailable) {
response = 6;
}
return response;
}
short checkUserIdAndEmail(boolean emailAvailable, boolean userIdAvailable) {
return userIdAvailable && emailAvailable ? 2 : 0
}
short checkEmailAndName(boolean emailAvailable, boolean nameAvailable) {
return emailAvailable && nameAvailable ? 5 : 0
}
short checkUserIdAndName(boolean userIdAvailable, boolean nameAvailable) {
return userIdAvailable && nameAvailable ? 3 : 0
}