Example usage for org.apache.commons.lang3.math NumberUtils toInt

List of usage examples for org.apache.commons.lang3.math NumberUtils toInt

Introduction

In this page you can find the example usage for org.apache.commons.lang3.math NumberUtils toInt.

Prototype

public static int toInt(final String str) 

Source Link

Document

Convert a String to an int, returning zero if the conversion fails.

If the string is null, zero is returned.

 NumberUtils.toInt(null) = 0 NumberUtils.toInt("")   = 0 NumberUtils.toInt("1")  = 1 

Usage

From source file:com.mirth.connect.client.ui.browsers.message.MessageBrowser.java

public int getPageSize() {
    return NumberUtils.toInt(pageSizeField.getText());
}

From source file:de.micromata.genome.gwiki.plugin.rogmp3_1_0.RogMp3ActionBean.java

private void renderMediaList() {
    XmlElement node = element("div", "name", "x");
    node.add(element("H1", text("Medien")));
    node.add(Html.p( //
            Html.a(attrs("href", localUrl() + "?showT=media"), text("Name")), //
            text(" |"), //
            Html.a(attrs("href",
                    localUrl() + "?showT=media&sort=" + Media.DATE_INDB + "&desc=" + (desc == false)),
                    text("Date")), //
            text(" |"), //
            Html.a(attrs("href", localUrl() + "?showT=media&sort=-1&desc=" + (desc == false)),
                    text("Usage Count")), //
            text(" |"), //
            Html.a(attrs("href", localUrl() + "?showT=media&sort=-2&desc=" + (desc == false)),
                    text("Usage Date")) //
    ));//from www .  j a v  a  2 s  . c  o m

    List<Media> medias = db.getMedia();
    if (NumberUtils.isNumber(sort) == true) {
        int isort = NumberUtils.toInt(sort);
        if (isort == -1) {
            Track.sortByUsage(medias, desc);
        } else if (isort == -2) {
            Track.sortByDate(medias, desc);
        } else {
            RecBase.sortByIdx(medias, isort, desc);
        }
    }
    node.add(code("<ul>"));
    for (Media m : medias) {
        node.add(Html.li(renderMediaLink(m)));
    }
    node.add(code("</ul>"));
    wikiContext.append(node.toString());
}

From source file:com.mirth.connect.client.ui.panels.connectors.QueueSettingsPanel.java

private void retryCountFieldKeyReleased(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_retryCountFieldKeyReleased
    if (NumberUtils.toInt(retryCountField.getText()) > 0) {
        retryIntervalField.setEnabled(true);
        retryIntervalLabel.setEnabled(true);
    } else if (queueNeverRadio.isSelected()) {
        retryIntervalField.setEnabled(false);
        retryIntervalLabel.setEnabled(false);
    }/*from   w  w w. j  a v a 2 s  . c  o m*/
}

From source file:com.kegare.caveworld.client.config.GuiBiomesEntry.java

@Override
public void handleMouseInput() {
    super.handleMouseInput();

    if (weightField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            weightField.setText(Integer.toString(Math.max(NumberUtils.toInt(weightField.getText()) - 1, 0)));
        } else if (i > 0) {
            weightField.setText(Integer.toString(Math.min(NumberUtils.toInt(weightField.getText()) + 1, 100)));
        }//from w  w  w .  j a  v a 2 s .c o  m
    } else if (terrainMetaField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            terrainMetaField
                    .setText(Integer.toString(Math.max(NumberUtils.toInt(terrainMetaField.getText()) - 1, 0)));
        } else if (i > 0) {
            terrainMetaField
                    .setText(Integer.toString(Math.min(NumberUtils.toInt(terrainMetaField.getText()) + 1, 15)));
        }
    } else if (topMetaField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            topMetaField.setText(Integer.toString(Math.max(NumberUtils.toInt(topMetaField.getText()) - 1, 0)));
        } else if (i > 0) {
            topMetaField.setText(Integer.toString(Math.min(NumberUtils.toInt(topMetaField.getText()) + 1, 15)));
        }
    }
}

From source file:com.moviejukebox.plugin.TheTvDBPlugin.java

/**
 * Use the movie information to find the series and ID
 *
 * @param movie/*ww  w. j  a  v a  2s  .  c  o  m*/
 * @return
 */
public static String findId(Movie movie) {
    String id = movie.getId(THETVDB_PLUGIN_ID);

    if (StringTools.isNotValidString(id)) {
        List<Series> seriesList = null;

        try {
            if (!movie.getTitle().equals(Movie.UNKNOWN)) {
                seriesList = TVDB.searchSeries(movie.getTitle(), LANGUAGE_PRIMARY);
                if ((seriesList == null || seriesList.isEmpty()) && !LANGUAGE_SECONDARY.isEmpty()) {
                    seriesList = TVDB.searchSeries(movie.getTitle(), LANGUAGE_SECONDARY);
                }
            }

            if (seriesList == null || seriesList.isEmpty()) {
                seriesList = TVDB.searchSeries(movie.getBaseName(), LANGUAGE_PRIMARY);
                if ((seriesList == null || seriesList.isEmpty()) && !LANGUAGE_SECONDARY.isEmpty()) {
                    seriesList = TVDB.searchSeries(movie.getBaseName(), LANGUAGE_SECONDARY);
                }
            }
        } catch (Exception error) {
            LOG.warn("Error getting ID: {}", error.getMessage());
        }

        if (seriesList == null || seriesList.isEmpty()) {
            return Movie.UNKNOWN;
        }

        Series series = null;
        for (Series s : seriesList) {
            if (StringTools.isValidString(s.getFirstAired())) {
                if (StringTools.isValidString(movie.getYear())) {
                    DateTime firstAired = DateTime.parse(s.getFirstAired());
                    if (NumberUtils.toInt(firstAired.toString("yyyy")) == NumberUtils.toInt(movie.getYear())) {
                        series = s;
                        break;
                    }
                } else {
                    series = s;
                    break;
                }
            }
        }

        // If we can't find an exact match, select the first one
        if (series == null) {
            series = seriesList.get(0);
            LOG.debug("No exact match for {} found, using {}", movie.getTitle(), series.getSeriesName());
        }

        id = String.valueOf(series.getId());

        series = getSeries(id);

        // Add the series to the cache (no need to get it again
        CacheMemory.addToCache(CacheMemory.generateCacheKey(CACHE_SERIES, id, LANGUAGE_PRIMARY), series);

        movie.setId(THETVDB_PLUGIN_ID, id);

        if (StringTools.isValidString(series.getImdbId())) {
            movie.setId(IMDB_PLUGIN_ID, series.getImdbId());
        }
    }

    return id;
}

From source file:de.micromata.genome.gwiki.plugin.rogmp3_1_0.RogMp3ActionBean.java

private void renderKomposerMedias(XmlElement node, Composer comp, List<Title> titels) {
    Map<String, Media> mediamap = new HashMap<String, Media>();
    for (Title tit : titels) {
        Media m = tit.getMedia();
        mediamap.put(m.getPk(), m);/*w  w  w. j ava  2  s .  c o m*/
    }
    List<Media> medias = new ArrayList<Media>();
    medias.addAll(mediamap.values());

    if (NumberUtils.isNumber(sort) == false) {
        sort = Integer.toString(Media.NAME1);
    }
    RecBase.sortByIdx(medias, NumberUtils.toInt(sort), desc);
    node.add(code("<ul>"));
    for (Media m : medias) {
        node.add(Html.li(renderMediaLink(m)));
    }
    node.add(code("</ul>"));
}

From source file:com.moviejukebox.plugin.SratimPlugin.java

public void scanTVShowTitles(Movie movie, String mainXML) {
    if (!movie.isTVShow() || !movie.hasNewMovieFiles()) {
        return;/*from w  ww  .  j  a v  a 2s.c  o m*/
    }

    String seasonXML = null;

    String newMainXML = mainXML;
    try {
        if (newMainXML == null) {
            String sratimId = movie.getId(SRATIM_PLUGIN_ID);
            newMainXML = httpClient.request("http://www.sratim.co.il/view.php?id=" + sratimId);
        }

        int season = movie.getSeason();

        int index = 0;
        int endIndex;

        String seasonUrl;
        String seasonYear;

        // Find the season URL
        while (true) {
            index = newMainXML.indexOf("<span class=\"smtext\"><a href=\"", index);
            if (index == -1) {
                return;
            }

            index += 30;

            endIndex = newMainXML.indexOf('\"', index);
            if (endIndex == -1) {
                return;
            }

            String scanUrl = newMainXML.substring(index, endIndex);

            index = newMainXML.indexOf("class=\"smtext\"> ", index);
            if (index == -1) {
                return;
            }

            index += 20;

            endIndex = newMainXML.indexOf("</a>", index);
            if (endIndex == -1) {
                return;
            }

            String scanSeason = newMainXML.substring(index, endIndex);

            index = newMainXML.indexOf("class=\"smtext\">", index);
            if (index == -1) {
                return;
            }

            index += 15;

            endIndex = newMainXML.indexOf('<', index);
            if (endIndex == -1) {
                return;
            }

            String scanYear = newMainXML.substring(index, endIndex);

            int scanSeasontInt = NumberUtils.toInt(scanSeason);

            if (scanSeasontInt == season) {
                seasonYear = scanYear;
                seasonUrl = "http://www.sratim.co.il/" + HTMLTools.decodeHtml(scanUrl);
                break;
            }
        }

        if (OverrideTools.checkOverwriteYear(movie, SRATIM_PLUGIN_ID)) {
            movie.setYear(seasonYear, SRATIM_PLUGIN_ID);
        }

        seasonXML = httpClient.request(seasonUrl);

    } catch (IOException error) {
        LOG.error("Failed retreiving information for movie : {}", movie.getId(SratimPlugin.SRATIM_PLUGIN_ID));
        LOG.error(SystemTools.getStackTrace(error));

        if (newMainXML == null) {
            return;
        }
    }

    if (seasonXML == null) {
        return;
    }

    for (MovieFile file : movie.getMovieFiles()) {
        if (!file.isNewFile()) {
            // don't scan episode if file is not new
            continue;
        }

        for (int part = file.getFirstPart(); part <= file.getLastPart(); ++part) {

            int index = 0;
            int endIndex;

            // Go over the page and sacn for episode links
            while (true) {
                index = seasonXML.indexOf("<td style=\"padding-right:6px;font-size:15px;\"><a href=\"", index);
                if (index == -1) {
                    return;
                }

                index += 55;

                endIndex = seasonXML.indexOf('\"', index);
                if (endIndex == -1) {
                    return;
                }

                String scanUrl = seasonXML.substring(index, endIndex);

                index = seasonXML.indexOf("<b> ", index);
                if (index == -1) {
                    return;
                }

                index += 7;

                endIndex = seasonXML.indexOf(':', index);
                if (endIndex == -1) {
                    return;
                }

                String scanPart = seasonXML.substring(index, endIndex);

                index = seasonXML.indexOf("</b> ", index);
                if (index == -1) {
                    return;
                }

                index += 5;

                endIndex = seasonXML.indexOf("</a>", index);
                if (endIndex == -1) {
                    return;
                }

                String scanName = seasonXML.substring(index, endIndex);

                if (scanPart.equals(Integer.toString(part))) {

                    if (OverrideTools.checkOverwriteEpisodeTitle(file, part, SRATIM_PLUGIN_ID)) {
                        String episodeTitle = logicalToVisual(HTMLTools.decodeHtml(scanName));
                        file.setTitle(part, episodeTitle, SRATIM_PLUGIN_ID);
                    }

                    try {
                        String episodeUrl = "http://www.sratim.co.il/" + HTMLTools.decodeHtml(scanUrl);

                        // Get the episode page url
                        String xml = httpClient.request(episodeUrl);

                        // Update Plot
                        if (OverrideTools.checkOverwriteEpisodePlot(file, part, SRATIM_PLUGIN_ID)) {
                            String plot = HTMLTools.extractTag(xml,
                                    "<div style=\"font-size:14px;text-align:justify;\">", "</div>");
                            plot = HTMLTools.removeHtmlTags(plot);
                            file.setPlot(part, breakLongLines(plot, plotLineMaxChar, plotLineMax),
                                    SRATIM_PLUGIN_ID);
                        }

                        // Download subtitles
                        // store the subtitles id in the movie ids map, make sure to remove the prefix "1" from the id
                        int findId = scanUrl.indexOf("id=");
                        String subId = scanUrl.substring(findId + 4);
                        movie.setId(SRATIM_PLUGIN_SUBTITLE_ID, subId);
                        downloadSubtitle(movie, file);

                    } catch (IOException error) {
                        LOG.error("Error - {}", error.getMessage());
                    }

                    break;
                }

            }
        }
    }
}

From source file:com.kegare.caveworld.client.config.GuiVeinsEntry.java

@Override
public void handleMouseInput() {
    super.handleMouseInput();

    if (blockMetaField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            blockMetaField/*from   ww  w . jav  a 2s. co m*/
                    .setText(Integer.toString(Math.max(NumberUtils.toInt(blockMetaField.getText()) - 1, 0)));
        } else if (i > 0) {
            blockMetaField
                    .setText(Integer.toString(Math.min(NumberUtils.toInt(blockMetaField.getText()) + 1, 15)));
        }
    } else if (countField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            countField.setText(Integer.toString(Math.max(NumberUtils.toInt(countField.getText()) - 1, 1)));
        } else if (i > 0) {
            countField.setText(Integer.toString(Math.min(NumberUtils.toInt(countField.getText()) + 1, 500)));
        }
    } else if (weightField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            weightField.setText(Integer.toString(Math.max(NumberUtils.toInt(weightField.getText()) - 1, 1)));
        } else if (i > 0) {
            weightField.setText(Integer.toString(Math.min(NumberUtils.toInt(weightField.getText()) + 1, 100)));
        }
    } else if (rateField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            rateField.setText(Integer.toString(Math.max(NumberUtils.toInt(rateField.getText()) - 1, 1)));
        } else if (i > 0) {
            rateField.setText(Integer.toString(Math.min(NumberUtils.toInt(rateField.getText()) + 1, 100)));
        }
    } else if (minHeightField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            minHeightField
                    .setText(Integer.toString(Math.max(NumberUtils.toInt(minHeightField.getText()) - 1, 0)));
        } else if (i > 0) {
            minHeightField.setText(Integer.toString(Math.min(NumberUtils.toInt(minHeightField.getText()) + 1,
                    NumberUtils.toInt(maxHeightField.getText()) - 1)));
        }
    } else if (maxHeightField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            maxHeightField.setText(Integer.toString(Math.max(NumberUtils.toInt(maxHeightField.getText()) - 1,
                    NumberUtils.toInt(minHeightField.getText()) + 1)));
        } else if (i > 0) {
            maxHeightField
                    .setText(Integer.toString(Math.min(NumberUtils.toInt(maxHeightField.getText()) + 1, 255)));
        }
    } else if (targetMetaField.isFocused()) {
        int i = Mouse.getDWheel();

        if (i < 0) {
            targetMetaField
                    .setText(Integer.toString(Math.max(NumberUtils.toInt(targetMetaField.getText()) - 1, 0)));
        } else if (i > 0) {
            targetMetaField
                    .setText(Integer.toString(Math.min(NumberUtils.toInt(targetMetaField.getText()) + 1, 15)));
        }
    }
}

From source file:com.moviejukebox.plugin.KinopoiskPlugin.java

/**
 * Scan Kinopoisk html page for the specified movie
 *//*from  ww  w  . j av a2s  .c o  m*/
private boolean updateKinopoiskMediaInfo(Movie movie, String kinopoiskId) {
    try {
        String originalTitle = movie.getTitle();
        String newTitle = originalTitle;
        String xml = httpClient.request(FILM_URL + kinopoiskId, CHARSET);
        boolean etalonFlag = kinopoiskId.equals(etalonId);
        // Work-around for issue #649
        xml = xml.replace("&#133;", "&hellip;");
        xml = xml.replace("&#151;", "&mdash;");

        // Title
        boolean overrideTitle = OverrideTools.checkOverwriteTitle(movie, KINOPOISK_PLUGIN_ID);
        if (overrideTitle || etalonFlag) {
            newTitle = HTMLTools.extractTag(xml, "class=\"moviename-big\" itemprop=\"name\">", 0, "</");
            if (StringTools.isValidString(newTitle)) {
                if (overrideTitle) {
                    int i = newTitle.indexOf("(?");
                    if (i >= 0) {
                        newTitle = newTitle.substring(0, i);
                        movie.setMovieType(Movie.TYPE_TVSHOW);
                    }
                    newTitle = newTitle.replace('\u00A0', ' ').trim();
                    if (movie.getSeason() != -1) {
                        newTitle = newTitle + ", ? " + movie.getSeason();
                    }

                    // Original title
                    originalTitle = newTitle;
                    for (String s : HTMLTools.extractTags(xml, "class=\"moviename-big\" itemprop=\"name\">",
                            "</span>", "itemprop=\"alternativeHeadline\">", "</span>")) {
                        if (!s.isEmpty()) {
                            originalTitle = s;
                            if (joinTitles) {
                                newTitle = newTitle + Movie.SPACE_SLASH_SPACE + originalTitle;
                            }
                        }
                        break;
                    }
                } else {
                    newTitle = originalTitle;
                }
            } else {
                if (etalonFlag) {
                    LOG.error(SITE_DESIGN, "movie title");
                }
                newTitle = originalTitle;
            }
        }

        // Plot
        if (OverrideTools.checkOverwritePlot(movie, KINOPOISK_PLUGIN_ID)) {
            StringBuilder plot = new StringBuilder();
            for (String subPlot : HTMLTools.extractTags(xml, "<span class=\"_reachbanner_\"", "</span>", "",
                    "<")) {
                if (!subPlot.isEmpty()) {
                    if (plot.length() > 0) {
                        plot.append(" ");
                    }
                    plot.append(subPlot);
                }
            }

            movie.setPlot(plot.toString(), KINOPOISK_PLUGIN_ID);

            if (etalonFlag && (plot.length() == 0)) {
                LOG.error(SITE_DESIGN, "plot");
            }
        }

        boolean valueFounded = false;
        boolean genresFounded = false;
        boolean certificationFounded = false;
        boolean countryFounded = false;
        boolean yearFounded = false;
        boolean runtimeFounded = false;
        boolean taglineFounded = false;
        boolean releaseFounded = false;
        for (String item : HTMLTools.extractTags(xml, "<table class=\"info\">", "</table>", "<tr", "</tr>")) {
            item = "<tr>" + item + "</tr>";
            // Genres
            if (OverrideTools.checkOverwriteGenres(movie, KINOPOISK_PLUGIN_ID)) {
                LinkedList<String> newGenres = new LinkedList<>();
                boolean innerGenresFound = false;
                for (String genre : HTMLTools.extractTags(item, "><", "</tr>",
                        "<a href=\"/lists/m_act%5Bgenre%5D/", "</a>")) {
                    innerGenresFound = true;
                    genre = genre.substring(0, 1).toUpperCase() + genre.substring(1, genre.length());
                    if ("".equalsIgnoreCase(genre)) {
                        newGenres.addFirst(genre);
                    } else {
                        newGenres.add(genre);
                    }
                }
                if (innerGenresFound) {
                    // Limit genres count
                    int maxGenres = 9;
                    try {
                        maxGenres = PropertiesUtil.getIntProperty("genres.max", 9);
                    } catch (Exception ignore) {
                        //
                    }
                    while (newGenres.size() > maxGenres) {
                        newGenres.removeLast();
                    }

                    movie.setGenres(newGenres, KINOPOISK_PLUGIN_ID);
                    genresFounded = true;
                }
            }

            // Certification from MPAA
            if (OverrideTools.checkOverwriteCertification(movie, KINOPOISK_PLUGIN_ID)) {
                if (!certificationFounded) {
                    certificationFounded = getCertification(movie, item, "> MPAA<", "</tr>",
                            "<a href=\"/film", "</a>", "alt=\" ");
                }
                if (!certificationFounded || russianCertification) {
                    certificationFounded |= getCertification(movie, item, ">?<", "</tr>",
                            "<td style=\"color", "</span>", "ageLimit ");
                }
            }

            // Country
            if (OverrideTools.checkOverwriteCountry(movie, KINOPOISK_PLUGIN_ID)) {
                Collection<String> scraped = HTMLTools.extractTags(item, ">?<", "</tr>",
                        "a href=\"/lists/m_act%5Bcountry%5D/", "</a>");
                if (scraped != null && !scraped.isEmpty()) {
                    List<String> countries = new ArrayList<>();
                    for (String country : scraped) {
                        if (translitCountry) {
                            country = FileTools.makeSafeFilename(country);
                        }
                        countries.add(country);

                        if (!countryAll) {
                            // just first country, so break here
                            break;
                        }
                    }
                    movie.setCountries(countries, KINOPOISK_PLUGIN_ID);
                    countryFounded = true;
                }
            }

            // Year
            if (OverrideTools.checkOverwriteYear(movie, KINOPOISK_PLUGIN_ID)) {
                for (String year : HTMLTools.extractTags(item, "><", "</tr>",
                        "<a href=\"/lists/m_act%5Byear%5D/", "</a>")) {
                    movie.setYear(year, KINOPOISK_PLUGIN_ID);
                    yearFounded = true;
                    break;
                }
            }

            // Run time
            if (OverrideTools.checkOverwriteRuntime(movie, KINOPOISK_PLUGIN_ID) || etalonFlag) {
                for (String runtime : HTMLTools.extractTags(item, ">?<", "</tr>", "<td", "</td>")) {
                    if (runtime.contains("<span")) {
                        runtime = runtime.substring(0, runtime.indexOf("<span"));
                    }
                    movie.setRuntime(runtime, KINOPOISK_PLUGIN_ID);
                    runtimeFounded = true;
                    break;
                }
            }

            // Tagline
            if (OverrideTools.checkOverwriteTagline(movie, KINOPOISK_PLUGIN_ID)) {
                for (String tagline : HTMLTools.extractTags(item, ">?<", "</tr>", "<td ", "</td>")) {
                    if (tagline.length() > 0) {
                        movie.setTagline(tagline.replace("\u00AB", "\"").replace("\u00BB", "\""),
                                KINOPOISK_PLUGIN_ID);
                        taglineFounded = true;
                        break;
                    }
                }
            }

            // Release date
            if (OverrideTools.checkOverwriteReleaseDate(movie, KINOPOISK_PLUGIN_ID)) {
                String releaseDate = "";
                for (String release : HTMLTools.extractTags(item, "> ()<", "</tr>",
                        "<a href=\"/film/", "</a>")) {
                    releaseDate = release;
                    releaseFounded = true;
                    break;
                }
                if (StringUtils.isBlank(releaseDate)) {
                    for (String release : HTMLTools.extractTags(item, "> ()<", "</tr>",
                            "<a href=\"/film/", "</a>")) {
                        releaseDate = release;
                        releaseFounded = true;
                        break;
                    }
                }
                movie.setReleaseDate(releaseDate, KINOPOISK_PLUGIN_ID);
            }
        }

        if (etalonFlag) {
            if (!genresFounded) {
                LOG.error(SITE_DESIGN, "genres");
            }
            if (!certificationFounded) {
                LOG.error(SITE_DESIGN, "certification");
            }
            if (!countryFounded) {
                LOG.error(SITE_DESIGN, "country");
            }
            if (!yearFounded) {
                LOG.error(SITE_DESIGN, "year");
            }
            if (!runtimeFounded) {
                LOG.error(SITE_DESIGN, "runtime");
            }
            if (!taglineFounded) {
                LOG.error(SITE_DESIGN, "tagline");
            }
            if (!releaseFounded) {
                LOG.error(SITE_DESIGN, "release");
            }
        }

        // Rating
        if (!nfoRating) {
            valueFounded = false;
            for (String rating : HTMLTools.extractTags(xml, "<a href=\"/film/" + kinopoiskId + "/votes/\"",
                    "</a>", "<span", "</span>")) {
                int kinopoiskRating = StringTools.parseRating(rating);
                movie.addRating(KINOPOISK_PLUGIN_ID, kinopoiskRating);
                valueFounded = true;
                break;
            }
            if (!valueFounded && etalonFlag) {
                LOG.error(SITE_DESIGN, "rating");
            }

            int imdbRating = movie.getRating(IMDB_PLUGIN_ID);
            if (imdbRating == -1 || etalonFlag) {
                // Get IMDB rating from kinopoisk page
                String rating = HTMLTools.extractTag(xml, ">IMDb:", 0, " (");
                valueFounded = false;
                if (StringTools.isValidString(rating)) {
                    imdbRating = StringTools.parseRating(rating);
                    movie.addRating(IMDB_PLUGIN_ID, imdbRating);
                    valueFounded = true;
                }
                if (!valueFounded && etalonFlag) {
                    LOG.error(SITE_DESIGN, "IMDB rating");
                }
            }
        }

        // Top250
        if (OverrideTools.checkOverwriteTop250(movie, KINOPOISK_PLUGIN_ID)) {
            movie.setTop250(HTMLTools.extractTag(xml, "<a href=\"/level/20/#", 0, "\""), KINOPOISK_PLUGIN_ID);
        }

        // Poster
        String posterURL = movie.getPosterURL();
        if (StringTools.isNotValidString(posterURL) || (!nfoPoster && poster) || etalonFlag) {
            valueFounded = false;
            if (poster || etalonFlag) {
                String previousURL = posterURL;
                posterURL = Movie.UNKNOWN;

                // Load page with all poster
                String wholeArts = httpClient.request(FILM_URL + kinopoiskId + "/posters/", CHARSET);
                if (StringTools.isValidString(wholeArts)) {
                    if (wholeArts.contains("<table class=\"fotos")) {
                        String picture = HTMLTools.extractTag(wholeArts,
                                "src=\"http://st.kinopoisk.ru/images/poster/sm_", 0, "\"");
                        if (StringTools.isValidString(picture)) {
                            posterURL = "http://st.kinopoisk.ru/images/poster/" + picture;
                            valueFounded = true;
                        }
                    }
                }

                if (StringTools.isNotValidString(posterURL)) {
                    posterURL = previousURL;
                }

                if (StringTools.isValidString(posterURL)) {
                    movie.setPosterURL(posterURL);
                    movie.setPosterFilename(movie.getBaseName() + ".jpg");
                    LOG.debug("Set poster URL to {} for {}", posterURL, movie.getBaseName());
                }
            }
            if (StringTools.isNotValidString(movie.getPosterURL())) {
                if (overrideTitle) {
                    movie.setTitle(originalTitle, KINOPOISK_PLUGIN_ID);
                }
                // Removing Poster info from plugins. Use of PosterScanner routine instead.
                // movie.setPosterURL(locatePosterURL(movie, ""));
            }
            if (!valueFounded && etalonFlag) {
                LOG.error(SITE_DESIGN, "poster");
            }
        }

        // Fanart
        String fanURL = movie.getFanartURL();
        if (StringTools.isNotValidString(fanURL) || (!nfoFanart && (fanArt || kadr)) || etalonFlag
                || fanURL.contains("originalnull")) {
            valueFounded = false;
            try {
                String previousURL = fanURL;
                fanURL = Movie.UNKNOWN;

                // Load page with all wallpaper
                String wholeArts = httpClient.request("http://www.kinopoisk.ru/film/" + kinopoiskId + "/wall/",
                        CHARSET);
                if (StringTools.isValidString(wholeArts)) {
                    if (wholeArts.contains("<table class=\"fotos")) {
                        String picture = HTMLTools.extractTag(wholeArts,
                                "src=\"http://st.kinopoisk.ru/images/wallpaper/sm_", 0, ".jpg");
                        if (StringTools.isValidString(picture)) {
                            if (picture.contains("_")) {
                                picture = picture.substring(0, picture.indexOf('_'));
                            }
                            String size = HTMLTools.extractTag(wholeArts,
                                    "<u><a href=\"/picture/" + picture + "/w_size/", 0, "/");
                            wholeArts = httpClient.request(
                                    "http://www.kinopoisk.ru/picture/" + picture + "/w_size/" + size, CHARSET);
                            if (StringTools.isValidString(wholeArts)) {
                                picture = HTMLTools.extractTag(wholeArts,
                                        "src=\"http://st-im.kinopoisk.r/im/wallpaper/", 0, "\"");
                                if (StringTools.isValidString(picture)) {
                                    fanURL = "http://st.kinopoisk.ru/im/wallpaper/" + picture;
                                    valueFounded = true;
                                }
                            }
                        }
                    }
                }

                if (kadr && (StringTools.isNotValidString(fanURL) || fanURL.contains("originalnull"))) {
                    // Load page with all videoimage
                    wholeArts = httpClient.request(FILM_URL + kinopoiskId + "/stills/", CHARSET);
                    if (StringTools.isValidString(wholeArts)) {
                        // Looking for photos table
                        int photosInd = wholeArts.indexOf("<table class=\"fotos");
                        if (photosInd != -1) {
                            String picture = HTMLTools.extractTag(wholeArts,
                                    "src=\"http://st.kinopoisk.ru/images/kadr/sm_", 0, "\"");
                            if (StringTools.isValidString(picture)) {
                                fanURL = "http://www.kinopoisk.ru/images/kadr/" + picture;
                                valueFounded = true;
                            }
                        }
                    }
                }

                if (StringTools.isNotValidString(fanURL)) {
                    fanURL = previousURL;
                }

                if (StringTools.isValidString(fanURL)) {
                    movie.setFanartURL(fanURL);
                    movie.setFanartFilename(movie.getBaseName() + fanartToken + "." + fanartExtension);
                    LOG.debug("Set fanart URL to {} for {}", fanURL, movie.getBaseName());
                }
            } catch (IOException ex) {
                // Ignore
            }
        }

        // Studio/Company
        if (OverrideTools.checkOverwriteCompany(movie, KINOPOISK_PLUGIN_ID)) {
            xml = httpClient.request(FILM_URL + kinopoiskId + "/studio/", CHARSET);
            valueFounded = false;
            if (StringTools.isValidString(xml)) {
                Collection<String> studio = new ArrayList<>();
                if (xml.contains(">?:<")) {
                    for (String tmp : HTMLTools.extractTags(xml, ">?:<", "</table>",
                            "<a href=\"/lists/m_act%5Bstudio%5D/", "</a>")) {
                        studio.add(HTMLTools.removeHtmlTags(tmp));
                        if (!companyAll) {
                            break;
                        }
                    }
                }
                if (xml.contains(">:<") && (companyAll || studio.isEmpty())) {
                    for (String tmp : HTMLTools.extractTags(xml, ">:<", "</table>",
                            "<a href=\"/lists/m_act%5Bcompany%5D/", "</a>")) {
                        studio.add(HTMLTools.removeHtmlTags(tmp));
                    }
                }
                if (!studio.isEmpty()) {
                    movie.setCompany(companyAll ? StringUtils.join(studio, Movie.SPACE_SLASH_SPACE)
                            : new ArrayList<>(studio).get(0), KINOPOISK_PLUGIN_ID);
                    valueFounded = true;
                }
            }
            if (!valueFounded && etalonFlag) {
                LOG.error(SITE_DESIGN, "company");
            }
        }

        // Awards
        if ((scrapeAwards && !nfoAwards) || etalonFlag) {
            if (clearAward) {
                movie.clearAwards();
            }
            xml = httpClient.request("http://www.kinopoisk.ru/film/" + kinopoiskId + "/awards/", CHARSET);
            Collection<AwardEvent> awards = new ArrayList<>();
            if (StringTools.isValidString(xml)) {
                int beginIndex = xml.indexOf("<b><a href=\"/awards/");
                if (beginIndex != -1) {
                    for (String item : HTMLTools.extractTags(xml,
                            "<table cellspacing=0 cellpadding=0 border=0 width=100%>",
                            "<br /><br /><br /><br /><br /><br />",
                            "<table cellspacing=\"0\" cellpadding=\"0\" border=\"0\" width=\"100%\" ",
                            "</table>")) {
                        String name = Movie.UNKNOWN;
                        int year = -1;
                        int won = 0;
                        int nominated = 0;
                        Collection<String> wons = new ArrayList<>();
                        Collection<String> nominations = new ArrayList<>();
                        for (String tmp : HTMLTools.extractTags(item,
                                "<td height=\"40\" class=\"news\" style=\"padding: 10px\">", "</td>",
                                "<a href=\"/awards/", "</a>")) {
                            int coma = tmp.indexOf(",");
                            name = tmp.substring(0, coma);
                            year = NumberUtils.toInt(tmp.substring(coma + 2, coma + 6));
                            break;
                        }
                        for (String tmp : HTMLTools.extractTags(item, "><", ":", "(",
                                ")")) {
                            won = NumberUtils.toInt(tmp);
                            break;
                        }
                        if (won > 0) {
                            for (String tmp : HTMLTools.extractTags(item, "><", "</ul>",
                                    "<li class=\"trivia\">", "</li>")) {
                                wons.add(HTMLTools.removeHtmlTags(tmp).replaceAll(" {2,}", " "));
                            }
                        }
                        for (String tmp : HTMLTools.extractTags(item, ">?<", ":", "(", ")")) {
                            nominated = NumberUtils.toInt(tmp);
                            break;
                        }
                        if (nominated > 0) {
                            for (String tmp : HTMLTools.extractTags(item, ">?<", "</ul>",
                                    "<li class=\"trivia\"", "</li>")) {
                                nominations.add(HTMLTools.removeHtmlTags(tmp).replaceAll(" {2,}", " "));
                            }
                        }
                        if (StringTools.isValidString(name) && year > 1900 && year < 2020
                                && (!scrapeWonAwards || (won > 0))) {
                            Award award = new Award();
                            award.setName(name);
                            award.setYear(year);
                            if (won > 0) {
                                award.setWons(wons);
                            }
                            if (nominated > 0) {
                                award.setNominations(nominations);
                            }

                            AwardEvent event = new AwardEvent();
                            event.setName(name);
                            event.addAward(award);
                            awards.add(event);
                        }
                    }
                }
            }
            if (!awards.isEmpty()) {
                movie.setAwards(awards);
            } else if (etalonFlag) {
                LOG.error(SITE_DESIGN, "award");
            }
        }

        // Cast enhancement
        boolean overrideCast = OverrideTools.checkOverwriteActors(movie, KINOPOISK_PLUGIN_ID);
        boolean overridePeopleCast = OverrideTools.checkOverwritePeopleActors(movie, KINOPOISK_PLUGIN_ID);
        boolean overrideDirectors = OverrideTools.checkOverwriteDirectors(movie, KINOPOISK_PLUGIN_ID);
        boolean overridePeopleDirectors = OverrideTools.checkOverwritePeopleDirectors(movie,
                KINOPOISK_PLUGIN_ID);
        boolean overrideWriters = OverrideTools.checkOverwriteWriters(movie, KINOPOISK_PLUGIN_ID);
        boolean overridePeopleWriters = OverrideTools.checkOverwritePeopleWriters(movie, KINOPOISK_PLUGIN_ID);

        if (overrideCast || overridePeopleCast || overrideDirectors || overridePeopleDirectors
                || overrideWriters || overridePeopleWriters || etalonFlag) {
            xml = httpClient.request(FILM_URL + kinopoiskId + "/cast", CHARSET);
            if (StringTools.isValidString(xml)) {
                if (overrideDirectors || overridePeopleDirectors || etalonFlag) {
                    int count = scanMoviePerson(movie, xml, "director", directorMax, overrideDirectors,
                            overridePeopleDirectors);
                    if (etalonFlag && count == 0) {
                        LOG.error(SITE_DESIGN, "directors");
                    }
                }
                if (overrideWriters || overridePeopleWriters || etalonFlag) {
                    int count = scanMoviePerson(movie, xml, "writer", writerMax, overrideWriters,
                            overridePeopleWriters);
                    if (etalonFlag && count == 0) {
                        LOG.error(SITE_DESIGN, "writers");
                    }
                }
                if (overrideCast || overridePeopleCast || etalonFlag) {
                    int count = scanMoviePerson(movie, xml, "actor", actorMax, overrideCast,
                            overridePeopleCast);
                    if (etalonFlag && count == 0) {
                        LOG.error(SITE_DESIGN, "cast");
                    }
                }

                Collection<Filmography> outcast = new ArrayList<>();
                for (Filmography p : movie.getPeople()) {
                    if (StringTools.isNotValidString(p.getId(KINOPOISK_PLUGIN_ID))) {
                        outcast.add(p);
                    }
                }
                for (Filmography p : outcast) {
                    movie.removePerson(p);
                }
            }
        }

        // Business
        if (scrapeBusiness || etalonFlag) {
            xml = httpClient.request(FILM_URL + kinopoiskId + "/box/", CHARSET);
            if (StringTools.isValidString(xml)) {
                valueFounded = false;
                for (String tmp : HTMLTools.extractTags(xml, ">:<", "</table>",
                        "<font color=\"#ff6600\"", "</h3>")) {
                    if (StringTools.isValidString(tmp)) {
                        tmp = tmp.replaceAll("\u00A0", ",").replaceAll(",$", "");
                        if (StringTools.isValidString(tmp) && !"--".equals(tmp)) {
                            movie.setBudget(tmp);
                            valueFounded = true;
                            break;
                        }
                    }
                }
                if (!valueFounded && etalonFlag) {
                    LOG.error(SITE_DESIGN, "business: summary");
                }
                valueFounded = false;
                for (String tmp : HTMLTools.extractTags(xml, "> -? (?)<",
                        "</table>", "<h3 style=\"font-size: 18px; margin: 0; padding: 0;color:#f60\"",
                        "</h3>")) {
                    if (StringTools.isValidString(tmp)) {
                        tmp = tmp.replaceAll("\u00A0", ",").replaceAll(",$", "");
                        if (StringTools.isValidString(tmp) && !"--".equals(tmp)) {
                            movie.setOpenWeek("USA", tmp);
                            valueFounded = true;
                            break;
                        }
                    }
                }
                if (!valueFounded && etalonFlag) {
                    LOG.error(SITE_DESIGN, "business: first weekend");
                }
                valueFounded = false;
                for (String tmp : HTMLTools.extractTags(xml, ">?? ?<", "</table>",
                        "<tr><td colspan=2", "</h3>")) {
                    tmp += "</h3>";
                    String country = HTMLTools.extractTag(tmp, ">", ":");
                    if (StringTools.isValidString(country)) {
                        String money = HTMLTools
                                .removeHtmlTags("<h3 " + HTMLTools.extractTag(tmp, "<h3 ", "</h3>"))
                                .replaceAll("\u00A0", ",").replaceAll(",$", "");
                        if (!"--".equals(money)) {
                            movie.setGross(
                                    " ??"
                                            .equals(country)
                                                    ? "Russia"
                                                    : " ?".equals(country) ? "USA"
                                                            : " ?".equals(country)
                                                                    ? "Worldwide"
                                                                    : "  ?".equals(
                                                                            country) ? "Others" : country,
                                    money);
                            valueFounded = true;
                        }
                    }
                }
                if (!valueFounded && etalonFlag) {
                    LOG.error(SITE_DESIGN, "business: gross");
                }
            } else if (etalonFlag) {
                LOG.error(SITE_DESIGN, "business");
            }
        }

        // Did You Know
        if (scrapeTrivia || etalonFlag) {
            if (clearTrivia) {
                movie.clearDidYouKnow();
            }
            if (etalonFlag && triviaMax == 0) {
                triviaMax = 1;
            }
            if (triviaMax != 0) {
                xml = httpClient.request(FILM_URL + kinopoiskId + "/view_info/ok/#trivia", CHARSET);
                if (StringTools.isValidString(xml)) {
                    int i = 0;
                    for (String tmp : HTMLTools.extractTags(xml, ">  , ...<", "</ul>",
                            "<li class=\"trivia", "</li>")) {
                        if (i < triviaMax || triviaMax == -1) {
                            movie.addDidYouKnow(HTMLTools.removeHtmlTags(tmp));
                            valueFounded = true;
                            i++;
                        } else {
                            break;
                        }
                    }
                }
            }
            if (!valueFounded && etalonFlag) {
                LOG.error(SITE_DESIGN, "trivia");
            }
        }

        // Finally set title
        if (overrideTitle) {
            movie.setTitle(newTitle, KINOPOISK_PLUGIN_ID);
        }
    } catch (IOException | NumberFormatException error) {
        LOG.error("Failed retreiving movie data from Kinopoisk : {}", kinopoiskId);
        LOG.error(SystemTools.getStackTrace(error));
    }
    return true;
}

From source file:com.mirth.connect.connectors.tcp.TcpReceiver.java

private void connectResponseSocket(Socket responseSocket, StreamHandler streamHandler) throws IOException {
    String channelId = getChannelId();
    String channelName = getChannel().getName();
    int responsePort = NumberUtils
            .toInt(replacer.replaceValues(connectorProperties.getResponsePort(), channelId, channelName));
    SocketUtil.connectSocket(responseSocket,
            replacer.replaceValues(connectorProperties.getResponseAddress(), channelId, channelName),
            responsePort, timeout);/* w  w w.  jav a 2s .  c  om*/
    initSocket(responseSocket);
    BufferedOutputStream bos = new BufferedOutputStream(responseSocket.getOutputStream(), bufferSize);
    streamHandler.setOutputStream(bos);
}