Example usage for org.hibernate.type LongType INSTANCE

List of usage examples for org.hibernate.type LongType INSTANCE

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.type.*
  5. LongType
  6. INSTANCE

Introduction

In this page you can find the example usage for org.hibernate.type LongType INSTANCE.

Prototype

LongType INSTANCE

To view the source code for org.hibernate.type LongType INSTANCE.

Click Source Link

Usage

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the files associated with a video ID.
 *
 * @param type//from   w w  w.j  av  a2  s  .  co m
 * @param id
 * @return
 */
private List<ApiFileDTO> getFilesForId(MetaDataType type, Long id) {
    // Build the SQL statement
    StringBuilder sbSQL = new StringBuilder();
    sbSQL.append(
            "SELECT mf.id as id, mf.extra as extra, mf.part as part, mf.part_title as partTitle, mf.movie_version as version, ");
    sbSQL.append(
            "mf.container as container, mf.codec as codec, mf.codec_format as codecFormat, mf.codec_profile as codecProfile, ");
    sbSQL.append("mf.bitrate as bitrate, mf.overall_bitrate as overallBitrate, mf.fps as fps, ");
    sbSQL.append(
            "mf.width as width, mf.height as height, mf.aspect_ratio as aspectRatio, mf.runtime as runtime, mf.video_source as videoSource, ");
    sbSQL.append(
            "sf.id as fileId, sf.full_path as fileName, sf.file_date as fileDate, sf.file_size as fileSize, ");

    if (type == MetaDataType.MOVIE) {
        sbSQL.append("null as season, null as episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf ");
        sbSQL.append("WHERE mv.videodata_id=:id ");
    } else if (type == MetaDataType.SERIES) {
        sbSQL.append("sea.season, vd.episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf, season sea, videodata vd ");
        sbSQL.append("WHERE sea.series_id=:id ");
        sbSQL.append("and vd.season_id=sea.id ");
        sbSQL.append("and mv.videodata_id=vd.id ");
    } else if (type == MetaDataType.SEASON) {
        sbSQL.append("sea.season, vd.episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf, season sea, videodata vd ");
        sbSQL.append("WHERE sea.id=:id ");
        sbSQL.append("and vd.season_id=sea.id ");
        sbSQL.append("and mv.videodata_id=vd.id ");
    } else if (type == MetaDataType.EPISODE) {
        sbSQL.append("sea.season, vd.episode ");
        sbSQL.append("FROM mediafile_videodata mv, mediafile mf, stage_file sf, season sea, videodata vd ");
        sbSQL.append("WHERE vd.id=:id ");
        sbSQL.append("and vd.season_id=sea.id ");
        sbSQL.append("and mv.videodata_id=vd.id ");
    }

    sbSQL.append("and mv.mediafile_id=mf.id ");
    sbSQL.append("and sf.mediafile_id=mf.id ");
    sbSQL.append("and sf.file_type='");
    sbSQL.append(FileType.VIDEO.toString());
    sbSQL.append("' and sf.status not in ('");
    sbSQL.append(StatusType.DUPLICATE.toString());
    sbSQL.append("','");
    sbSQL.append(StatusType.DELETED.toString());
    sbSQL.append("') ");

    if (type == MetaDataType.SERIES || type == MetaDataType.SEASON) {
        sbSQL.append("ORDER BY sea.season ASC, vd.episode ASC");
    }

    SqlScalars sqlScalars = new SqlScalars(sbSQL);
    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("extra", BooleanType.INSTANCE);
    sqlScalars.addScalar("part", IntegerType.INSTANCE);
    sqlScalars.addScalar("partTitle", StringType.INSTANCE);
    sqlScalars.addScalar("version", StringType.INSTANCE);
    sqlScalars.addScalar("container", StringType.INSTANCE);
    sqlScalars.addScalar("codec", StringType.INSTANCE);
    sqlScalars.addScalar("codecFormat", StringType.INSTANCE);
    sqlScalars.addScalar("codecProfile", StringType.INSTANCE);
    sqlScalars.addScalar("bitrate", IntegerType.INSTANCE);
    sqlScalars.addScalar("overallBitrate", IntegerType.INSTANCE);
    sqlScalars.addScalar("fps", FloatType.INSTANCE);
    sqlScalars.addScalar("width", IntegerType.INSTANCE);
    sqlScalars.addScalar("height", IntegerType.INSTANCE);
    sqlScalars.addScalar("aspectRatio", StringType.INSTANCE);
    sqlScalars.addScalar("runtime", IntegerType.INSTANCE);
    sqlScalars.addScalar("videoSource", StringType.INSTANCE);
    sqlScalars.addScalar("fileId", LongType.INSTANCE);
    sqlScalars.addScalar("fileName", StringType.INSTANCE);
    sqlScalars.addScalar("fileDate", TimestampType.INSTANCE);
    sqlScalars.addScalar("fileSize", LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, LongType.INSTANCE);
    sqlScalars.addScalar(EPISODE, LongType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    List<ApiFileDTO> results = executeQueryWithTransform(ApiFileDTO.class, sqlScalars, null);
    if (CollectionUtils.isNotEmpty(results)) {
        for (ApiFileDTO file : results) {
            file.setAudioCodecs(this.getAudioCodecs(file.getId()));
            file.setSubtitles(this.getSubtitles(file.getId()));
        }
    }
    return results;
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the files associated with a video ID.
 *
 * @param type/*ww  w. ja v  a 2  s .co  m*/
 * @param id
 * @return
 */
private List<ApiTrailerDTO> getTrailersForId(MetaDataType type, Long id) {
    if (MetaDataType.SERIES != type && MetaDataType.MOVIE != type) {
        // just for movies and series
        return Collections.emptyList();
    }

    // Build the SQL statement
    StringBuilder sbSQL = new StringBuilder();
    sbSQL.append(
            "SELECT t.id, t.title, t.url, t.source, t.hash_code as hashCode, t.cache_dir as cacheDir, t.cache_filename as cacheFilename ");
    sbSQL.append("FROM trailer t ");

    if (type == MetaDataType.SERIES) {
        sbSQL.append("WHERE t.series_id=:id ");
    } else {
        sbSQL.append("WHERE t.videodata_id=:id ");
    }
    sbSQL.append("and t.status not in ('IGNORE','DELETED') ");
    sbSQL.append("order by t.id ");

    SqlScalars sqlScalars = new SqlScalars(sbSQL);
    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar("url", StringType.INSTANCE);
    sqlScalars.addScalar("source", StringType.INSTANCE);
    sqlScalars.addScalar("hashCode", StringType.INSTANCE);
    sqlScalars.addScalar("cacheDir", StringType.INSTANCE);
    sqlScalars.addScalar("cacheFilename", StringType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiTrailerDTO.class, sqlScalars, null);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the studios for a given video ID
 *
 * @param type//from   www .  j a v a  2  s . co m
 * @param id
 * @return
 */
private List<Studio> getStudiosForId(MetaDataType type, Long id) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT DISTINCT s.id, s.name ");
    sqlScalars.addToSql("FROM studio s ");
    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("JOIN series_studios ss ON s.id=ss.studio_id and ss.series_id=:id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("JOIN season sea ON sea.id = :id ");
        sqlScalars.addToSql("JOIN series_studios ss ON s.id=ss.studio_id and ss.series_id=sea.series_id ");
    } else {
        // defaults to movie
        sqlScalars.addToSql("JOIN videodata_studios vs ON s.id=vs.studio_id and vs.data_id=:id ");
    }
    sqlScalars.addToSql("ORDER BY name");

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("name", StringType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(Studio.class, sqlScalars, null);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the genres for a given video ID
 *
 * @param type//from   w w  w  .  j a v a 2s . c o m
 * @param id
 * @return
 */
private List<ApiCountryDTO> getCountriesForId(MetaDataType type, Long id) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT c.id, c.country_code as countryCode ");
    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("FROM series_countries sc, country c ");
        sqlScalars.addToSql("WHERE sc.series_id=:id ");
        sqlScalars.addToSql("AND sc.country_id=c.id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("FROM season sea, series_countries sc, country c ");
        sqlScalars.addToSql("WHERE sea.id=:id ");
        sqlScalars.addToSql("AND sc.series_id=sea.series_id ");
        sqlScalars.addToSql("AND sc.country_id=c.id ");
    } else {
        // defaults to movie
        sqlScalars.addToSql("FROM videodata_countries vc, country c ");
        sqlScalars.addToSql("WHERE vc.data_id=:id ");
        sqlScalars.addToSql("AND vc.country_id=c.id ");
    }

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("countryCode", StringType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiCountryDTO.class, sqlScalars, null);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the certifications for a given video ID
 *
 * @param type// w  w w. j av a  2  s .c o  m
 * @param id
 * @return
 */
private List<ApiCertificationDTO> getCertificationsForId(MetaDataType type, Long id) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT DISTINCT c.id, c.country_code as countryCode, c.certificate ");
    sqlScalars.addToSql("FROM certification c ");
    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("JOIN series_certifications sc ON c.id=sc.cert_id and sc.series_id=:id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("JOIN season sea ON sea.id = :id ");
        sqlScalars.addToSql("JOIN series_certifications sc ON c.id=sc.cert_id and sc.series_id=sea.series_id ");
    } else {
        // defaults to movie
        sqlScalars.addToSql("JOIN videodata_certifications vc ON c.id=vc.cert_id and vc.data_id=:id ");
    }
    sqlScalars.addToSql("ORDER BY country_code, certificate");

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("countryCode", StringType.INSTANCE);
    sqlScalars.addScalar("certificate", StringType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiCertificationDTO.class, sqlScalars, null);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a list of the cast for a given video ID
 *
 * @param type/*from w ww  . ja  va  2s .c o m*/
 * @param id
 * @return
 */
private List<ApiPersonDTO> getCastForId(MetaDataType type, Long id, List<DataItem> dataItems,
        Set<String> jobs) {
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql("SELECT DISTINCT p.id,");
    if (dataItems.contains(DataItem.BIOGRAPHY)) {
        sqlScalars.addToSql("p.biography,");
        sqlScalars.addScalar("biography", StringType.INSTANCE);
    }
    sqlScalars.addToSql("p.name,");
    sqlScalars.addToSql("p.first_name AS firstName,");
    sqlScalars.addToSql("p.last_name AS lastName,");
    sqlScalars.addToSql("p.birth_day AS birthDay,");
    sqlScalars.addToSql("p.birth_place AS birthPlace,");
    sqlScalars.addToSql("p.birth_name AS birthName,");
    sqlScalars.addToSql("p.death_day AS deathDay,");
    sqlScalars.addToSql("p.death_place AS deathPlace,");
    sqlScalars.addToSql("c.role as role,");
    sqlScalars.addToSql("c.job as jobTypeAsString ");
    sqlScalars.addToSql("FROM person p ");

    if (type == MetaDataType.SERIES) {
        sqlScalars.addToSql("JOIN cast_crew c ON p.id=c.person_id ");
        sqlScalars.addToSql("JOIN season sea ON sea.series_id=:id ");
        sqlScalars.addToSql("JOIN videodata vd ON vd.id=c.videodata_id and vd.season_id=sea.id ");
    } else if (type == MetaDataType.SEASON) {
        sqlScalars.addToSql("JOIN cast_crew c ON p.id=c.person_id ");
        sqlScalars.addToSql("JOIN videodata vd ON vd.id=c.videodata_id and vd.season_id=:id ");
    } else {
        // defaults to movie/episode
        sqlScalars.addToSql("JOIN cast_crew c ON p.id=c.person_id and c.videodata_id=:id ");
    }

    if (jobs != null) {
        sqlScalars.addToSql("WHERE c.job in (:jobs) ");
        sqlScalars.addParameter("jobs", jobs);
    }
    sqlScalars.addToSql("ORDER BY c.ordering");

    sqlScalars.addScalar(ID, LongType.INSTANCE);
    sqlScalars.addScalar("name", StringType.INSTANCE);
    sqlScalars.addScalar("firstName", StringType.INSTANCE);
    sqlScalars.addScalar("lastName", StringType.INSTANCE);
    sqlScalars.addScalar("birthDay", DateType.INSTANCE);
    sqlScalars.addScalar("birthPlace", StringType.INSTANCE);
    sqlScalars.addScalar("birthName", StringType.INSTANCE);
    sqlScalars.addScalar("deathDay", DateType.INSTANCE);
    sqlScalars.addScalar("deathPlace", StringType.INSTANCE);
    sqlScalars.addScalar("role", StringType.INSTANCE);
    sqlScalars.addScalar("jobTypeAsString", StringType.INSTANCE);
    sqlScalars.addParameter(ID, id);

    return executeQueryWithTransform(ApiPersonDTO.class, sqlScalars, null);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a select list of artwork available for a video ID
 *
 * @param type/*from   w  w  w  .j av  a2  s  . c o m*/
 * @param id
 * @param artworkRequired
 * @return
 */
public Map<Long, List<ApiArtworkDTO>> getArtworkForId(MetaDataType type, Object id,
        Set<String> artworkRequired) {
    LOG.trace("Artwork required for {} ID {} is {}", type, id, artworkRequired);

    StringBuilder sbSQL = new StringBuilder();
    sbSQL.append("SELECT '").append(type.toString()).append("' AS sourceString,");
    sbSQL.append(" v.id AS sourceId, a.id AS artworkId, al.id AS locatedId, ag.id AS generatedId,");
    sbSQL.append(
            " a.artwork_type AS artworkTypeString, ag.cache_dir AS cacheDir, ag.cache_filename AS cacheFilename ");
    if (type == MetaDataType.MOVIE) {
        sbSQL.append("FROM videodata v ");
    } else if (type == MetaDataType.SERIES) {
        sbSQL.append("FROM series v ");
    } else if (type == MetaDataType.SEASON) {
        sbSQL.append("FROM season v ");
    } else if (type == MetaDataType.PERSON) {
        sbSQL.append("FROM person v");
    } else if (type == MetaDataType.BOXSET) {
        sbSQL.append("FROM boxed_set v");
    }
    sbSQL.append(", artwork a"); // Artwork must be last for the LEFT JOIN
    sbSQL.append(SQL_LEFT_JOIN_ARTWORK_LOCATED);
    sbSQL.append(SQL_LEFT_JOIN_ARTWORK_GENERATED);
    if (type == MetaDataType.MOVIE) {
        sbSQL.append(" WHERE v.id=a.videodata_id");
        sbSQL.append(" AND v.episode<0");
    } else if (type == MetaDataType.SERIES) {
        sbSQL.append(" WHERE v.id=a.series_id");
    } else if (type == MetaDataType.SEASON) {
        sbSQL.append(" WHERE v.id=a.season_id");
    } else if (type == MetaDataType.PERSON) {
        sbSQL.append(" WHERE v.id=a.person_id");
    } else if (type == MetaDataType.BOXSET) {
        sbSQL.append(" WHERE v.id=a.boxedset_id");
    }
    sbSQL.append(" AND al.id is not null");
    sbSQL.append(" AND v.id IN (:id)");
    sbSQL.append(SQL_ARTWORK_TYPE_IN_ARTWORKLIST);

    SqlScalars sqlScalars = new SqlScalars(sbSQL);
    LOG.info("Artwork SQL: {}", sqlScalars.getSql());

    sqlScalars.addScalar("sourceString", StringType.INSTANCE);
    sqlScalars.addScalar("sourceId", LongType.INSTANCE);
    sqlScalars.addScalar("artworkId", LongType.INSTANCE);
    sqlScalars.addScalar("locatedId", LongType.INSTANCE);
    sqlScalars.addScalar("generatedId", LongType.INSTANCE);
    sqlScalars.addScalar("artworkTypeString", StringType.INSTANCE);
    sqlScalars.addScalar(CACHE_DIR, StringType.INSTANCE);
    sqlScalars.addScalar(CACHE_FILENAME, StringType.INSTANCE);

    sqlScalars.addParameter(ID, id);
    sqlScalars.addParameter("artworklist", artworkRequired);

    List<ApiArtworkDTO> results = executeQueryWithTransform(ApiArtworkDTO.class, sqlScalars, null);
    return generateIdMapList(results);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

public void getSeriesInfo(ApiWrapperList<ApiSeriesInfoDTO> wrapper) {
    OptionsIdArtwork options = (OptionsIdArtwork) wrapper.getOptions();
    Long id = options.getId();//from  www.j  a  v a  2  s . c om
    LOG.info("Getting series information for series ID {}", id);

    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql(
            "SELECT s.id AS seriesId, s.title, s.title_original AS originalTitle, s.start_year AS seriesYear, ");
    if (options.hasDataItem(DataItem.PLOT)) {
        sqlScalars.addToSql("s.plot, ");
        sqlScalars.addScalar("plot", StringType.INSTANCE);
    }
    if (options.hasDataItem(DataItem.OUTLINE)) {
        sqlScalars.addToSql("s.outline, ");
        sqlScalars.addScalar("outline", StringType.INSTANCE);
    }
    sqlScalars.addToSql(
            "(SELECT min(vid.watched_nfo or vid.watched_file or vid.watched_api) from videodata vid,season sea where vid.season_id=sea.id and sea.series_id=s.id) as watched ");
    sqlScalars.addToSql("FROM series s");
    sqlScalars.addToSql("WHERE id=:id");
    sqlScalars.addToSql("ORDER BY id");
    sqlScalars.addParameter(ID, id);

    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(SERIES_YEAR, IntegerType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);

    List<ApiSeriesInfoDTO> seriesResults = executeQueryWithTransform(ApiSeriesInfoDTO.class, sqlScalars,
            wrapper);
    LOG.debug("Found {} series for ID {}", seriesResults.size(), id);

    for (ApiSeriesInfoDTO series : seriesResults) {
        if (options.hasDataItem(DataItem.GENRE)) {
            series.setGenres(getGenresForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.STUDIO)) {
            series.setStudios(getStudiosForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.COUNTRY)) {
            series.setCountries(getCountriesForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.CERTIFICATION)) {
            series.setCertifications(getCertificationsForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.RATING)) {
            series.setRatings(getRatingsForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.AWARD)) {
            series.setAwards(getAwardsForId(MetaDataType.SERIES, id));
        }

        if (options.hasDataItem(DataItem.ARTWORK)) {
            Map<Long, List<ApiArtworkDTO>> artworkList = getArtworkForId(MetaDataType.SERIES, id,
                    options.getArtworkTypes());
            if (artworkList == null || !artworkList.containsKey(id)
                    || CollectionUtils.isEmpty(artworkList.get(id))) {
                LOG.debug("No artwork found for seriesId {}", id);
            } else {
                for (ApiArtworkDTO artwork : artworkList.get(id)) {
                    series.addArtwork(artwork);
                }
            }
        }
        series.setSeasonList(getSeasonInfo(options));
    }
    wrapper.setResults(seriesResults);
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

private List<ApiSeasonInfoDTO> getSeasonInfo(OptionsIdArtwork options) {
    Long id = options.getId();//w  w  w  .j  a v  a2 s.  c  o  m

    LOG.debug("Getting season information for series ID {}", id);
    SqlScalars sqlScalars = new SqlScalars();
    sqlScalars.addToSql(
            "SELECT s.series_id AS seriesId, s.id AS seasonId, s.season, s.title, s.title_original AS originalTitle,");
    if (options.hasDataItem(DataItem.PLOT)) {
        sqlScalars.addToSql("s.plot, ");
        sqlScalars.addScalar("plot", StringType.INSTANCE);
    }
    if (options.hasDataItem(DataItem.OUTLINE)) {
        sqlScalars.addToSql("s.outline, ");
        sqlScalars.addScalar("outline", StringType.INSTANCE);
    }
    sqlScalars.addToSql(
            "(SELECT min(vid.watched_nfo or vid.watched_file or vid.watched_api) from videodata vid where vid.season_id=s.id) as watched ");
    sqlScalars.addToSql("FROM season s");
    sqlScalars.addToSql("WHERE series_id=:id");
    sqlScalars.addToSql("ORDER BY series_id, season");
    sqlScalars.addParameter(ID, id);

    sqlScalars.addScalar(SERIES_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON_ID, LongType.INSTANCE);
    sqlScalars.addScalar(SEASON, IntegerType.INSTANCE);
    sqlScalars.addScalar(TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(ORIGINAL_TITLE, StringType.INSTANCE);
    sqlScalars.addScalar(WATCHED, BooleanType.INSTANCE);

    List<ApiSeasonInfoDTO> seasonResults = executeQueryWithTransform(ApiSeasonInfoDTO.class, sqlScalars, null);
    LOG.debug("Found {} seasons for series ID {}", seasonResults.size(), id);

    if (options.hasDataItem(DataItem.ARTWORK)) {
        for (ApiSeasonInfoDTO season : seasonResults) {
            Map<Long, List<ApiArtworkDTO>> artworkList = getArtworkForId(MetaDataType.SEASON,
                    season.getSeasonId(), options.getArtworkTypes());
            if (artworkList == null || !artworkList.containsKey(season.getSeasonId())
                    || CollectionUtils.isEmpty(artworkList.get(season.getSeasonId()))) {
                LOG.debug("No artwork found for series ID {} and season {}", id, season.getSeason());
            } else {
                for (ApiArtworkDTO artwork : artworkList.get(season.getSeasonId())) {
                    season.addArtwork(artwork);
                }
            }
        }
    }

    return seasonResults;
}

From source file:org.yamj.core.database.dao.ApiDao.java

License:Open Source License

/**
 * Get a single Count and Timestamp/*from w ww. ja  va  2s  . c o m*/
 *
 * @param type
 * @param tablename
 * @param clause
 * @return
 */
public CountTimestamp getCountTimestamp(MetaDataType type, String tablename, String clause) {
    if (StringUtils.isBlank(tablename)) {
        return null;
    }

    StringBuilder sql = new StringBuilder("SELECT '").append(type).append("' as typeString, ");
    sql.append("count(*) as count, ");
    sql.append("MAX(create_timestamp) as createTimestamp, ");
    sql.append("MAX(update_timestamp) as updateTimestamp, ");
    sql.append("MAX(id) as lastId ");
    sql.append("FROM ").append(tablename);
    if (StringUtils.isNotBlank(clause)) {
        sql.append(" WHERE ").append(clause);
    }

    SqlScalars sqlScalars = new SqlScalars(sql);

    sqlScalars.addScalar("typeString", StringType.INSTANCE);
    sqlScalars.addScalar("count", LongType.INSTANCE);
    sqlScalars.addScalar("createTimestamp", TimestampType.INSTANCE);
    sqlScalars.addScalar("updateTimestamp", TimestampType.INSTANCE);
    sqlScalars.addScalar("lastId", LongType.INSTANCE);

    List<CountTimestamp> results = executeQueryWithTransform(CountTimestamp.class, sqlScalars, null);
    if (CollectionUtils.isEmpty(results)) {
        return new CountTimestamp(type);
    }

    return results.get(0);
}