private void printException(TestDescriptor descriptor, Throwable exception, boolean cause, int indentLevel, StringBuilder builder) { String indent = Strings.repeat(INDENT, indentLevel); builder.append(indent); if (cause) { builder.append("Caused by: "); } String className = exception instanceof PlaceholderException ? ((PlaceholderException) exception).getExceptionClassName() : exception.getClass().getName(); builder.append(className); StackTraceFilter filter = new StackTraceFilter(new ClassMethodNameStackTraceSpec(descriptor.getClassName(), null)); List<StackTraceElement> stackTrace = filter.filter(exception); if (stackTrace.size() > 0) { StackTraceElement element = stackTrace.get(0); builder.append(" at "); builder.append(element.getFileName()); builder.append(':'); builder.append(element.getLineNumber()); } builder.append('\n'); if (testLogging.getShowCauses() && exception.getCause() != null) { printException(descriptor, exception.getCause(), true, indentLevel + 1, builder); } }
private Map<String, ApolloConfigNotification> filterNotifications(String appId, List<ApolloConfigNotification> notifications) { Map<String, ApolloConfigNotification> filteredNotifications = Maps.newHashMap(); for (ApolloConfigNotification notification : notifications) { if (Strings.isNullOrEmpty(notification.getNamespaceName())) { continue; } //strip out .properties suffix String originalNamespace = namespaceUtil.filterNamespaceName(notification.getNamespaceName()); notification.setNamespaceName(originalNamespace); //fix the character case issue, such as FX.apollo <-> fx.apollo String normalizedNamespace = namespaceUtil.normalizeNamespace(appId, originalNamespace); // in case client side namespace name has character case issue and has difference notification ids // such as FX.apollo = 1 but fx.apollo = 2, we should let FX.apollo have the chance to update its notification id // which means we should record FX.apollo = 1 here and ignore fx.apollo = 2 if (filteredNotifications.containsKey(normalizedNamespace) && filteredNotifications.get(normalizedNamespace).getNotificationId() < notification.getNotificationId()) { continue; } filteredNotifications.put(normalizedNamespace, notification); } return filteredNotifications; }
/** * Produce collection of files found within the given path * * @param path A file location. * @return The list of files at the file location. */ static Collection<Path> checkPath(String path) { Collection<Path> existingFiles = new LinkedList<>(); if (Strings.isNullOrEmpty(path)) { return existingFiles; } if (path.contains("*")) { return manyPath(path); } Path file = fileSystem.getPath(path); if (Files.exists(file)) { existingFiles.add(file); } else { DEV_LOG.error(FILE_DOES_NOT_EXIST, file.toAbsolutePath()); } return existingFiles; }
@Override public CompletableFuture<Long> onLogin(ChannelHandlerContext ctx, SocketASK ask) { // 整个消息就是 token ByteString tokenArg = ask.getBody().getArgs(0); if (tokenArg == null) { logger.info("Token arg must be input."); return null; } String token = tokenArg.toStringUtf8(); if (Strings.isNullOrEmpty(token)) { logger.info("Token arg must be input."); return null; } return CompletableFuture.supplyAsync(() -> { String parseToken = new String(BaseEncoding.base64Url().decode(token)); List<String> tokenChars = Splitter.on('|').splitToList(parseToken); return Long.valueOf(tokenArg.toStringUtf8()); }); }
@Override public void sendMessageToAll(final List<IncomingMessage> incomingMessageList) { final Set<Prefs.UserPrefs> subscribers = PrefsController.instance.getPrefs().getEventListeners(); es.submit(new Runnable() { @Override public void run() { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(botService.getString(com.rai220.securityalarmbot.R.string.incoming_messages)); for (IncomingMessage message : incomingMessageList) { stringBuilder.append(message.getPhone()); if (!Strings.isNullOrEmpty(message.getName())) { stringBuilder.append(" (").append(message.getName()).append(")"); } stringBuilder.append(": \"").append(message.getMessage()).append("\"\n"); } for (final Prefs.UserPrefs user : subscribers) { bot.execute(new SendMessage(user.lastChatId, stringBuilder.toString())); } } }); }
@Subscribe public final void updateTileViewModel( final BuildTypeData data ) { if ( data != _buildTypeData ) return; Platform.runLater( ( ) -> { _displayedName.set( Strings.isNullOrEmpty( data.getAliasName( ) ) ? data.getName( ) : data.getAliasName( ) ); _running.setValue( data.hasRunningBuild( ) ); _queued.setValue( data.isQueued( ) ); updateLastFinishedDate( ); updateTimeLeft( ); updatePercentageComplete( ); updateBackground( ); updateIcon( ); } ); }
@Override public FilterResult filterRequest(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { if( CurrentInstitution.get() != null ) { String path = (request.getServletPath() + Strings.nullToEmpty(request.getPathInfo())).substring(1); // Disallow overriding of CSS files supplied by plugins. Clients // should always override CSS rules in customer.css if( CSS_PROVIDED_BY_PLUGIN.matcher(path).matches() ) { return FilterResult.FILTER_CONTINUE; } // Remove the version number from the path which is there to // facilitate long expiry dates. final Matcher m = REMOVE_VERSION_FROM_PATH.matcher(path); if( m.matches() ) { path = "p/r/" + m.group(1); } CustomisationFile customFile = new CustomisationFile(); if( fileService.fileExists(customFile, path) ) { String mimeType = mimeTypeService.getMimeTypeForFilename(path); FileContentStream contentStream = fileService.getContentStream(customFile, path, mimeType); contentStreamWriter.outputStream(request, response, contentStream); response.flushBuffer(); } } return FilterResult.FILTER_CONTINUE; }
void addNewExample(Example origEx) { // Create the new example, but only add relevant information. Example ex = new Example.Builder() .setId(origEx.id) .setUtterance(origEx.utterance) .setContext(origEx.context) .setTargetFormula(origEx.targetFormula) .setTargetValue(origEx.targetValue) .createExample(); if (!Strings.isNullOrEmpty(opts.newExamplesPath)) { LogInfo.begin_track("Adding new example"); Dataset.appendExampleToFile(opts.newExamplesPath, ex); LogInfo.end_track(); } if (opts.onlineLearnExamples) { LogInfo.begin_track("Updating parameters"); learner.onlineLearnExample(origEx); if (!Strings.isNullOrEmpty(opts.newParamsPath)) builder.params.write(opts.newParamsPath); LogInfo.end_track(); } }
@Override public String getUrl() { String name = "e"; try { name = URLEncoder.encode(getEvent().map(Event::getName) .map(newName -> newName.replace(" ", "_")) .map(newName -> newName.replace("/", "")) .map(newName -> Strings.padStart(newName, 1, 'e')) .orElse("#"), "UTF-8"); } catch (UnsupportedEncodingException e) { logger.info("[Occurrence] [getUrl] Failure To Encode URL", e); } return String.format( "/Events/%s/%s?startTime=%s", getEvent().map(Event::getIdBase64).orElse(""), name, // uuidToBase64(getEvent().getId()), String.valueOf(getStartTime().getMillis()) ); }
protected void renderDebugInfoLeft() { List list = this.call(); for (int i = 0; i < list.size(); ++i) { String s = (String)list.get(i); if (!Strings.isNullOrEmpty(s)) { int j = this.fontRenderer.FONT_HEIGHT; int k = this.fontRenderer.getStringWidth(s); boolean flag = true; int l = 2 + j * i; drawRect(1, l - 1, 2 + k + 1, l + j - 1, -1873784752); this.fontRenderer.drawString(s, 2, l, 14737632); } } }
/** * Creates a {@link FileSelection selection} with the given file statuses and selection root. * * @param statuses list of file statuses * @param root root path for selections * * @return null if creation of {@link FileSelection} fails with an {@link IllegalArgumentException} * otherwise a new selection. * */ private static FileSelection create(StatusType status, final ImmutableList<FileStatus> statuses, final String root) { if (statuses == null || statuses.size() == 0) { return null; } final String selectionRoot; if (Strings.isNullOrEmpty(root)) { throw new IllegalArgumentException("Selection root is null or empty" + root); } final Path rootPath = handleWildCard(root); final URI uri = statuses.get(0).getPath().toUri(); final Path path = new Path(uri.getScheme(), uri.getAuthority(), rootPath.toUri().getPath()); selectionRoot = Path.getPathWithoutSchemeAndAuthority(path).toString(); return new FileSelection(status, statuses, selectionRoot); }
public static Topic serviceInbox(@NotNull String serviceName, String inboxName) { StringBuilder topic = new StringBuilder(); topic.append("inbox"); if (!Strings.isNullOrEmpty(inboxName)) { topic.append("_"); topic.append(inboxName); } if (Strings.isNullOrEmpty(serviceName)) { throw new IllegalArgumentException("service name must not be null or empty"); } topic.append("-"); topic.append(serviceName); return new Topic(topic.toString()); }
static boolean parametersOk(final String[] keys, final String[] values) { if (keys == null || values == null) { return false; } if (keys.length != values.length) { return false; } for (final String key : keys) { if (Strings.isNullOrEmpty(key)) { return false; } } for (final String value : values) { if (Strings.isNullOrEmpty(value)) { return false; } } return true; }
private String withLineNumbers(String code) { try { return CharStreams.readLines(new StringReader(code), new LineProcessor<String>() { private final StringBuilder lines = new StringBuilder(); private int lineNo = 1; @Override public boolean processLine(String line) throws IOException { lines.append(Strings.padStart(String.valueOf(lineNo++), 3, ' ')).append(": ").append(line) .append("\n"); return true; } @Override public String getResult() { return lines.toString(); } }); } catch (IOException e) { throw new IllegalStateException(e.getMessage()); } }
private static void hackNatives() { String paths = System.getProperty("java.library.path"); String nativesDir = "C:/Users/Sergio/.gradle/caches/minecraft/net/minecraft/natives/1.8"; if (Strings.isNullOrEmpty(paths)) paths = nativesDir; else paths += File.pathSeparator + nativesDir; System.setProperty("java.library.path", paths); // hack the classloader now. try { final Field sysPathsField = ClassLoader.class.getDeclaredField("sys_paths"); sysPathsField.setAccessible(true); sysPathsField.set(null, null); } catch(Throwable t) {}; }
/** * Returns URI to execution module from runtime environment. */ public Optional<String> getExecModuleURI(List<IN4JSProject> extendedDeps) { List<String> execModules = extendedDeps.stream() .filter(p -> ProjectType.RUNTIME_ENVIRONMENT.equals(p.getProjectType())) .map(re -> { Optional<URI> execModuleAsURI = projectUtils.getExecModuleAsURI(re); if (!execModuleAsURI.isPresent()) { return null; } return compilerHelper.getTargetFileName(re, execModuleAsURI.get(), null); }) .filter(s -> !Strings.isNullOrEmpty(s)) .collect(Collectors.toList()); if (execModules.size() >= 1) return Optional.of(execModules.get(0)); return Optional.absent(); }
/** * Create and return proxy user {@link org.apache.hadoop.security.UserGroupInformation} for give user name. * * @param proxyUserName Proxy user name (must be valid) * @return */ public static UserGroupInformation createProxyUgi(String proxyUserName) { try { if (Strings.isNullOrEmpty(proxyUserName)) { throw new IllegalArgumentException("Invalid value for proxy user name"); } // If the request proxy user is same as process user name or same as system user, return the process UGI. if (proxyUserName.equals(getProcessUserName()) || SYSTEM_USERNAME.equals(proxyUserName)) { return getProcessUserUGI(); } return CACHE.get(new Key(proxyUserName, UserGroupInformation.getLoginUser())); } catch (IOException | ExecutionException e) { final String errMsg = "Failed to create proxy user UserGroupInformation object: " + e.getMessage(); logger.error(errMsg, e); throw new RuntimeException(errMsg, e); } }
public String getDbPassword() throws IOException { String password = passwordDecrypted; String configPasswordEncrypted = getEnvironmentVariable(ConfigKeys.DatabaseEncryptedPassword, false); if (Strings.isNullOrEmpty(configPasswordEncrypted)) { password = getEnvironmentVariable(ConfigKeys.DatabasePassword); } else { if (Strings.isNullOrEmpty(password) || !configPasswordEncrypted.equalsIgnoreCase(passwordEncrypted)) { password = getEnvironmentVariable(ConfigKeys.DatabaseEncryptedPassword); passwordEncrypted = configPasswordEncrypted; passwordDecrypted = password; } } return password; }
/** * Getting variable from one of the multiple sources available * @param key variable name * @return string result */ public String getVariable(String key) { // checking VM options for properties String sysPropertyValue = System.getProperty(key); if (!Strings.isNullOrEmpty(sysPropertyValue)) return sysPropertyValue; // checking enviroment variables for properties String envPropertyValue = System.getenv(key); if (!Strings.isNullOrEmpty(envPropertyValue)) return envPropertyValue; // checking resource file for property if (prop != null) { String property = prop.getProperty(key); if (!Strings.isNullOrEmpty(property)) return property; } return ""; }
@Bean public ServletContextInitializer servletContextInitializer() { return new ServletContextInitializer() { @Override public void onStartup(ServletContext servletContext) throws ServletException { String loggingServerIP = portalConfig.cloggingUrl(); String loggingServerPort = portalConfig.cloggingPort(); String credisServiceUrl = portalConfig.credisServiceUrl(); servletContext.setInitParameter("loggingServerIP", Strings.isNullOrEmpty(loggingServerIP) ? "" : loggingServerIP); servletContext.setInitParameter("loggingServerPort", Strings.isNullOrEmpty(loggingServerPort) ? "" : loggingServerPort); servletContext.setInitParameter("credisServiceUrl", Strings.isNullOrEmpty(credisServiceUrl) ? "" : credisServiceUrl); } }; }
public static <R> List<R> extractParam(String param, Function<String, R> converter) { String[] params = param.split(PARAM_DELIMITE); List<R> list = new ArrayList<>(params.length); for (String item : params) { item = item.trim(); if (Strings.isNullOrEmpty(item)) { continue; } R apply = converter.apply(item); if (apply != null) { list.add(apply); } } return list; }
/** * Decodes a sdk version from either its decimal representation or from a platform code name. * @param attributeVersion the sdk version attribute as specified by users. * @return the integer representation of the platform level. */ private static int getApiLevelFromAttribute(String attributeVersion) { Preconditions.checkArgument(!Strings.isNullOrEmpty(attributeVersion)); if (Character.isDigit(attributeVersion.charAt(0))) { return Integer.parseInt(attributeVersion); } return SdkVersionInfo.getApiByPreviewName(attributeVersion, true); }
private BinaryLexicon() throws IOException { if (Strings.isNullOrEmpty(opts.binaryLexiconFilesPath)) throw new RuntimeException("Missing unary lexicon file"); fbFormulasInfo = FbFormulasInfo.getSingleton(); // if we omit prepositions then the lexicon normalizer does that, otherwise, it is a normalizer that does nothing lexiconLoadingNormalizer = new PrepDropNormalizer(); // the alignment lexicon already contains stemmed stuff so just need to drop prepositions read(opts.binaryLexiconFilesPath); }
@Override public String getDisplayName() { String txt; if (Strings.isNullOrEmpty(libraryName)) { txt = "project '" + projectPath + "'"; } else if (Strings.isNullOrEmpty(variant)) { txt = "project '" + projectPath + "' library '" + libraryName + "'"; } else { txt = "project '" + projectPath + "' library '" + libraryName + "' binary '" + variant + "'"; } return txt; }
private boolean scopeEquals(String lhs, String rhs) { if ("COMPILE".equals(lhs)) { return Strings.isNullOrEmpty(rhs) || "COMPILE".equals(rhs); } else if ("COMPILE".equals(rhs)) { return Strings.isNullOrEmpty(lhs) || "COMPILE".equals(lhs); } else { return Objects.equal(lhs, rhs); } }
@ParameterizedTest @ValueSource(strings = { "T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"}) void testFromString(String input) { WebHookToken token = WebHookToken.fromString(input); Assertions.assertFalse(Strings.isNullOrEmpty(token.partB())); Assertions.assertFalse(Strings.isNullOrEmpty(token.partT())); Assertions.assertFalse(Strings.isNullOrEmpty(token.partX())); Assertions.assertFalse(Strings.isNullOrEmpty(token.toString())); }
public static void assertValid(Attachment attachment) { attachment.fields().forEach(FieldTests::assertValid); assertFalse(Strings.isNullOrEmpty(attachment.fallback())); Optional.ofNullable(attachment.color()).ifPresent(ColorTests::assertValid); attachment.pretext().ifPresent(pretext -> assertFalse(Strings.isNullOrEmpty(pretext))); Optional.ofNullable(attachment.author()).ifPresent(AuthorTests::assertValid); Optional.ofNullable(attachment.title()).ifPresent(TitleTests::assertValid); attachment.text().ifPresent(text -> assertFalse(Strings.isNullOrEmpty(text))); attachment.imageUrl().ifPresent(imageUrl -> assertFalse(Strings.isNullOrEmpty(imageUrl.toString()))); attachment.thumbUrl().ifPresent(thumbUrl -> assertFalse(Strings.isNullOrEmpty(thumbUrl.toString()))); Optional.ofNullable(attachment.footer()).ifPresent(FooterTests::assertValid); }
/** * Defines the different classloaders to be created. Number of classloaders can be * different than number of plugins. */ @VisibleForTesting Collection<PluginClassLoaderDef> defineClassloaders(Map<String, PluginInfo> infoByKeys) { Map<String, PluginClassLoaderDef> classloadersByBasePlugin = new HashMap<>(); for (PluginInfo info : infoByKeys.values()) { String baseKey = basePluginKey(info, infoByKeys); PluginClassLoaderDef def = classloadersByBasePlugin.get(baseKey); if (def == null) { def = new PluginClassLoaderDef(baseKey); classloadersByBasePlugin.put(baseKey, def); } ExplodedPlugin explodedPlugin = jarExploder.explode(info); def.addFiles(asList(explodedPlugin.getMain())); def.addFiles(explodedPlugin.getLibs()); def.addMainClass(info.getKey(), info.getMainClass()); for (String defaultSharedResource : DEFAULT_SHARED_RESOURCES) { def.getExportMask().addInclusion(String.format("%s/%s/api/", defaultSharedResource, info.getKey())); } // The plugins that extend other plugins can only add some files to classloader. // They can't change metadata like ordering strategy or compatibility mode. if (Strings.isNullOrEmpty(info.getBasePlugin())) { def.setSelfFirstStrategy(info.isUseChildFirstClassLoader()); } } return classloadersByBasePlugin.values(); }
private static String combine(String packageName, String className) { if (Strings.isNullOrEmpty(packageName)) { return className; } if (Strings.isNullOrEmpty(className)) { return packageName; } return packageName + "." + className; }
@Override @SuppressWarnings("SimplifiableIfStatement") public boolean canClose(@Nullable String json) { if (Strings.isNullOrEmpty(json)) { return false; } try { final JsonElement root = parser.parse(json); return !root.isJsonNull() && !root.isJsonPrimitive(); } catch (JsonParseException e) { return false; } }
public String getContextDescription() { StringBuilder sb = new StringBuilder(); if (request != null) { if (! Strings.isNullOrEmpty(request.getRequestURI())) { String method = Strings.nullToEmpty(request.getMethod()); String query = (Strings.isNullOrEmpty(request.getQueryString())) ? "" : "?" + request.getQueryString(); sb.append(String.format(" uri: %s %s%s\n", method, request.getRequestURI(), query)); } if (request.getUserPrincipal() != null) { sb.append(String.format(" userPrincipal: %s\n", request.getUserPrincipal().toString())); } if (request.getRemoteAddr() != null) { sb.append(String.format(" remoteAddr: %s\n", request.getRemoteAddr())); } } else { log.warn("Request context null in exceptionUtil"); } if (headers != null) { Joiner joiner = Joiner.on(", ").skipNulls(); headers.getRequestHeaders().entrySet().forEach(entry -> { String headerName = entry.getKey(); String headerValue = joiner.join(entry.getValue()); sb.append(String.format(" Header: %s = %s\n", headerName, headerValue)); }); } return sb.toString(); }
public void validate() throws ClientException { if (Strings.isNullOrEmpty(serviceName)) { throw new ClientException("Service name cannot be blank"); } if (Strings.isNullOrEmpty(functionName)) { throw new ClientException("Function name cannot be blank"); } }
@Override public void reset() { super.reset(); if (!Strings.isNullOrEmpty(getTextEntryPresenter().getText())) { presenter.setText(StringUtils.EMPTY_STRING); updateResponse(false, true); } sourcelistManager.onUserValueChanged(); }
/** * 上传文件 */ public String uploadFile(byte[] fileBytes, long size, String path, String ext) throws IOException { InputStream inputStream = new ByteArrayInputStream(fileBytes); String filePath = Strings.isNullOrEmpty(path) ? "upload": path; String fileId = Md5Util.getMD5(fileBytes); //UUID.randomUUID().toString().replace("-", ""); String fileName = String.format("%s/%s.%s", filePath, fileId, ext); this.upload(inputStream, size, fileName); return ossConfig.getBaseOssUri() + fileName; }
private void validateIssuer(Issuer issuer) { String issuerId = issuer.getValue(); if (Strings.isNullOrEmpty(issuerId)) { SamlValidationSpecificationFailure failure = SamlTransformationErrorFactory.missingIssuer(); throw new SamlTransformationErrorException(failure.getErrorMessage(), failure.getLogLevel()); } }
@Value.Check protected final void check() { MorePreconditions.checkAtLeastOnePresentAndValid( ImmutableList.of("prefix", "suffix"), ImmutableList.of(prefix(), suffix())); checkArgument(!Strings.isNullOrEmpty(separator()), "Separator should be present and valid (non-null, non-empty String)"); }
@Override public void callback(CmdCallbackQueueItem cmdQueueItem) { BigInteger jobId = cmdQueueItem.getJobId(); Cmd cmd = cmdQueueItem.getCmd(); Job job = jobDao.get(jobId); // if not found job, re enqueue if (job == null) { throw new NotFoundException("job"); } if (Job.FINISH_STATUS.contains(job.getStatus())) { LOGGER.trace("Reject cmd callback since job %s already in finish status", job.getId()); return; } if (cmd.getType() == CmdType.CREATE_SESSION) { onCreateSessionCallback(job, cmd); return; } if (cmd.getType() == CmdType.RUN_SHELL) { String path = cmd.getExtra(); if (Strings.isNullOrEmpty(path)) { throw new IllegalParameterException("Node path is required for cmd RUN_SHELL callback"); } onRunShellCallback(path, cmd, job); return; } if (cmd.getType() == CmdType.DELETE_SESSION) { LOGGER.trace("Session been deleted for job: %s", cmdQueueItem.getJobId()); return; } LOGGER.warn("not found cmdType, cmdType: %s", cmd.getType().toString()); throw new NotFoundException("not found cmdType"); }
public ApiOutboundRequest(EBrokerCommands command, ERequestMethod requestMethod, String requestUrl) { if(command == null || requestMethod == null || Strings.isNullOrEmpty(requestUrl)) throw new IllegalArgumentException("No null arguments permitted"); this.command = command; this.requestMethod = requestMethod; this.requestUrl = requestUrl; this.clientRequests = new ArrayList<>(); }
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (args.length < 2) { sender.sendMessage(ChatColor.RED + "Usage: " + getUsage(label)); return true; } OfflinePlayer target = Bukkit.getOfflinePlayer(args[1]); // TODO: breaking if (!target.hasPlayedBefore() && !target.isOnline()) { sender.sendMessage(ChatColor.GOLD + "Player '" + ChatColor.WHITE + args[1] + ChatColor.GOLD + "' not found."); return true; } Deathban deathban = plugin.getUserManager().getUser(target.getUniqueId()).getDeathban(); if (deathban == null || !deathban.isActive()) { sender.sendMessage(ChatColor.RED + target.getName() + " is not death-banned."); return true; } sender.sendMessage(ChatColor.DARK_AQUA + "Deathban cause of " + target.getName() + '.'); sender.sendMessage(ChatColor.GRAY + " Time: " + DateTimeFormats.HR_MIN.format(deathban.getCreationMillis())); sender.sendMessage(ChatColor.GRAY + " Duration: " + DurationFormatUtils.formatDurationWords(deathban.getInitialDuration(), true, true)); Location location = deathban.getDeathPoint(); if (location != null) { sender.sendMessage(ChatColor.GRAY + " Location: (" + location.getBlockX() + ", " + location.getBlockY() + ", " + location.getBlockZ() + ") - " + location.getWorld().getName()); } sender.sendMessage(ChatColor.GRAY + " Reason: [" + Strings.nullToEmpty(deathban.getReason()) + ChatColor.GREEN + "]"); return true; }
/** * Similar to {@link #getUserByPhoneNumberAsync(String)}, but returns a {@link Task}. * * @param phoneNumber A user phone number string. * @return A {@link Task} which will complete successfully with a {@link UserRecord} instance. * If an error occurs while retrieving user data or if the phone number does not * correspond to a user, the task fails with a {@link FirebaseAuthException}. * @throws IllegalArgumentException If the phone number is null or empty. * @deprecated Use {@link #getUserByPhoneNumberAsync(String)} */ public Task<UserRecord> getUserByPhoneNumber(final String phoneNumber) { checkNotDestroyed(); checkArgument(!Strings.isNullOrEmpty(phoneNumber), "phone number must not be null or empty"); return call(new Callable<UserRecord>() { @Override public UserRecord call() throws Exception { return userManager.getUserByPhoneNumber(phoneNumber); } }); }